https://rn-wissen.de/wiki/api.php?action=feedcontributions&feedformat=atom&user=RobertoRN-Wissen.de - Benutzerbeiträge [de]2026-04-11T16:11:05ZBenutzerbeiträgeMediaWiki 1.25.1https://rn-wissen.de/wiki/index.php?title=Bascom_und_PWM&diff=12819Bascom und PWM2007-10-20T00:26:25Z<p>Roberto: /* Grundprogramm */</p>
<hr />
<div>== PWM-Signale mit Bascom erzeugen ==<br />
<br />
===Grundbegriffe===<br />
Bei der ''Puls-Weiten-Modulation'' ([[PWM]]) wird ein digitales Ausgangssignal erzeugt, dessen Tastverhältnis moduliert wird.<br />
<br />
Das Tastverhältnis gibt das Verhältnis der Länge des eingeschalteten Zustands zur Periodendauer an. Dabei bleiben die Frequenz und der Pegel des Signals immer<br />
gleich! <br />
Es ändert sich nur die Länge von High zu Low.<br />
<br />
Folgendes Bild zeigt ein Tastverhältnis einmal von 10% und einmal von 50%<br />
<br />
[[Bild:Tastverhältnis.png|center]]<br />
<br />
Man könnte das in etwa mit einem Wasserhahn vergleichen, den man z.B. alle Minuten betätigt.<br />
Wenn man ihn in jeder Minute nur kurz aufdreht und dann gleich wieder zumacht, <br />
kommt in Summe nur wenig Wasser raus. <br />
Wenn man ihn aber in jeder dieser Minuten länger offen lässt, <br />
kommt mehr Wasser raus.<br />
<br />
Der Rhythmus bleibt immer gleich, aber es ändert sich in Summe die Wassermenge,<br />
die raus kommt.<br />
<br />
Mit dem [[PWM]]-Signal kann man nun tolle Sachen machen. <br /><br />
Zum Beispiel:<br />
* eine [[LED]] (oder über einen [[Transistor]] auch eine Lampe) an den [[PWM]]-Ausgang anschliessen und mit der Länge des [[PWM]]-Signal’s die Helligkeit der [[LED]] verändern.<br />
* einen Motor in der Geschwindigkeit regeln. <br />
* mittels nachgeschaltetem RC-Filter, welcher das [[PWM]]-Signal glättet, kann eine Gleichspannung erzeugt werden die zwischen 0V und 5V geregelt werden kann.<br />
<br />
=== PWM-Arten ===<br />
<br />
Es gibt zwei Arten PWM-Signale in Bascom zu erzeugen:<br />
<br />
==== Software PWM ====<br />
:'''Vorteile''': <br />
::* es kann (fast) jeder Ausgabe-Pin des AVR benutzt werden.<br />
::* unter zuhilfename eines (freien) [[Timer]]s k&ouml;nnen sogar mehrere verschiedene PWM-Signale auf verschiedene Pins erzeugt werden.<br />
:'''Nachteil''': <br />
::* Etwas gr&ouml;sserer Programmaufwand, da der PortPin per Software verändert werden muss.<br />
<br />
==== Hardware PWM ====<br />
:'''Vorteile''':<br />
::* Sehr schnell (Maximal die Quarzfrequenz / Periode)<br />
::* unabhängig vom Programmablauf des AVR<br />
:'''Nachteile''':<br />
::* Je nach AVR k&ouml;nnen nur bestimmte Timer mit bestimmten Ausgangspins daf&uuml;r verwendet werden.<br />
::* belegt den Timer, der für keine weiteren funktionen verwendet werden kann.<br />
<br />
<br />
Beim einem [[ATMega8]] stehen drei Hardware-PWM-Ausg&auml;nge verteilt auf zwei Timer zur Verf&uuml;gung.<br />
<br />
Mit Timer1 können zwei PWM Signale erzeugt werden <br />
(Compare A => OC1A - Pin 15 und Compare B => OC1B - Pin 16).<br />
<br />
Die Auflösung kann auf 8, 9 und 10 Bit eingestellt werden, also max. 1024 Abstufungen.<br />
<br />
Timer2 kann ein PWM-Signal mit einer Auflösung von 8 Bit erzeugen<br />
<br />
(Compare Register => OC2 - Pin 17)<br />
<br />
=== PWM-Ablauf ===<br />
<br />
Das folgende Bild zeigt den Ablauf bei Timer1. Als Taktquelle dient die CPU-Frequenz, dessen Frequenz im Prescaler (Vorteiler) nochmal verkleinert werden kann.<br />
Je nach eingestelltem Wert in den ''Output Compare Registern'' wird der Status des Ausgangs-Pin entsprechend oft umgeschaltet, <br />
und erzeugt somit das PWM-Signal.<br />
<br />
[[Bild:PWM.png|center]]<br />
<br />
<br />
=== Genauere Erklärung ===<br />
<br />
Der Prescaler teilt die Frequenz die vom Quarz kommt!<br />
Bei Teilung 1 geht die vollständige Frequenz zum Timer.<br />
Bei Teilung 8 nur ein Achtel der Quarzfrequenz.<br />
(Also bei 8 MHz Quarz kommen zum Timer dann nur 1 MHz )<br />
Bei Teilung 1024 sind es dann z.B. 8 MHz/1024 = 7,8125kHz <br />
<br />
Der Timer ist hier der Zähler für die PWM.<br />
Er zählt mit der Frequenz, die vom Prescaler kommt, einmal von 0 bis<br />
zu der eingestellten Timerauflösung rauf, dann wieder auf 0 zurück.<br />
(dann wieder von 0 auf Timerauflösung u.s.w.)<br />
Einmal rauf- und runterzählen, ergibt ein Periode.<br />
Die Periode ist gleich die Ausgangsfrequenz des PWM-Signals.<br />
Ausgangsfrequenz = (Quarzfrequenz/Prescale ) /(Timerauflösung*2)<br />
<br />
z.B.: Quarz = 8 MHz ; Prescaler = 1 ; Timer = 8 Bit<br />
ergibt: (8000000Hz/1) / (256*2) = 15,625 kHz<br/><br />
<br />
oder: Quarz = 8 MHz ; Prescaler = 8 ; Timer = 10 Bit<br />
ergibt: (8000000Hz/8) / (1024*2) = 244,14 Hz<br />
<br />
Mit dem Compare Register definiert man nun das Tastverhältnis!<br />
Überall, wo nun der Timer diese Compare Linie schneidet, schaltet der Ausgang!<br />
Beim raufzählen des Timers auf EIN, beim runterzählen auf AUS.<br />
<br />
<br />
<br />
Als Beispiel ein Tastverhältnis von 20%<br />
[[Bild:Compare205.png|center]]<br />
<br />
<br />
Als Beispiel ein Tastverhältnis von 80%<br />
[[Bild:Compare51.png|center]]<br />
<br />
<br />
<br />
Hier sieht man, wie die Signale auf einem Oszilloskop ausschauen.<br />
Oben das Signal von Pin15 (Compare A), unten das von Pin 16 (Compare B)<br />
[[Bild:Osci-PWM-kleiner3.GIF|center]]<br />
<br />
=== Grundprogramm ===<br />
<br />
Hier nun ein Grundprogramm für die Ausgabe von zwei PWM Signalen mit dem Timer1<br />
<br />
<pre><br />
' Hardware PWM mit Timer1<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 4000000<br />
<br />
Config Portb.1 = Output<br />
Config Portb.2 = Output<br />
<br />
Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1<br />
<br />
Do<br />
Compare1a = 205<br />
Compare1b = 51<br />
Loop<br />
<br />
End<br />
</pre><br />
<br />
<br />
''' Erklärung:'''<br />
<pre><br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
</pre><br />
Definiert den Mega8 und den 8MHz Quarz<br />
<br />
<br />
<pre><br />
Config Portb.1 = Output<br />
Config Portb.2 = Output<br />
</pre><br />
Definiert die zwei Ausgänge von Timer1 auf Ausgabe.<br/><br />
Portb.1 = für Compare1a (= Compare A) = Pin 15<br/><br />
Portb.2 = für Compare1b (= Compare B) = Pin 16<br />
<br />
<br />
<br />
<pre><br />
Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1<br />
</pre><br />
;Config Timer1 = Pwm<br />
: Timer1 auf PWM einstellen<br />
<br />
;Pwm = 8 <br />
:Timer Auflösung = 8 Bit einstellen<br />
<br />
;Compare A Pwm = Clear Up:Definiert, wie der Compare A schalten soll. Bei „Clear Up“ schaltet der Ausgang beim erreichen <br />
:des Compare-Wertes zuerst auf High und dann auf Low. Bei „Clear Down“, umgekehrt. <br />
<br />
;Compare B Pwm = Clear Up<br />
:Das gleiche noch mal mit Compare B <br />
<br />
;Prescale = 1<br />
:Hier wird der Prescaler auf 1 eingestellt.<br />
:(Wert 1 heißt, direkte Frequenz vom Quarz zum Timer.)<br />
:Weitere Teilungen, wie z.B.: 8, 64, 256 und 1024 sind möglich.<br />
<br />
<br />
<br />
<pre><br />
Compare1a = 205<br />
Compare1b = 51<br />
</pre> <br />
Hier kann man nun die Werte für das Tastverhältnis, in dem Register Compare1a<br />
und Compare1b übergeben. Oder man kann, statt Compare1a und 1b, auch die Bezeichnungen <br />
Pwm1a und Pwm1b verwenden, Bascom nimmt beides.<br />
<br />
<br />
Mit diesem kurzen Programm, hat man nun zwei [[PWM]] Signale erzeugt, bei dem eines ein Tastverhältnis<br />
von 20% (Compare1a) und das andere 80 % hat. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[Pwm]]<br />
* [[Timer]]<br />
* [[Bascom und Timer]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_PWM&diff=12818Bascom und PWM2007-10-20T00:23:49Z<p>Roberto: /* Grundprogramm */</p>
<hr />
<div>== PWM-Signale mit Bascom erzeugen ==<br />
<br />
===Grundbegriffe===<br />
Bei der ''Puls-Weiten-Modulation'' ([[PWM]]) wird ein digitales Ausgangssignal erzeugt, dessen Tastverhältnis moduliert wird.<br />
<br />
Das Tastverhältnis gibt das Verhältnis der Länge des eingeschalteten Zustands zur Periodendauer an. Dabei bleiben die Frequenz und der Pegel des Signals immer<br />
gleich! <br />
Es ändert sich nur die Länge von High zu Low.<br />
<br />
Folgendes Bild zeigt ein Tastverhältnis einmal von 10% und einmal von 50%<br />
<br />
[[Bild:Tastverhältnis.png|center]]<br />
<br />
Man könnte das in etwa mit einem Wasserhahn vergleichen, den man z.B. alle Minuten betätigt.<br />
Wenn man ihn in jeder Minute nur kurz aufdreht und dann gleich wieder zumacht, <br />
kommt in Summe nur wenig Wasser raus. <br />
Wenn man ihn aber in jeder dieser Minuten länger offen lässt, <br />
kommt mehr Wasser raus.<br />
<br />
Der Rhythmus bleibt immer gleich, aber es ändert sich in Summe die Wassermenge,<br />
die raus kommt.<br />
<br />
Mit dem [[PWM]]-Signal kann man nun tolle Sachen machen. <br /><br />
Zum Beispiel:<br />
* eine [[LED]] (oder über einen [[Transistor]] auch eine Lampe) an den [[PWM]]-Ausgang anschliessen und mit der Länge des [[PWM]]-Signal’s die Helligkeit der [[LED]] verändern.<br />
* einen Motor in der Geschwindigkeit regeln. <br />
* mittels nachgeschaltetem RC-Filter, welcher das [[PWM]]-Signal glättet, kann eine Gleichspannung erzeugt werden die zwischen 0V und 5V geregelt werden kann.<br />
<br />
=== PWM-Arten ===<br />
<br />
Es gibt zwei Arten PWM-Signale in Bascom zu erzeugen:<br />
<br />
==== Software PWM ====<br />
:'''Vorteile''': <br />
::* es kann (fast) jeder Ausgabe-Pin des AVR benutzt werden.<br />
::* unter zuhilfename eines (freien) [[Timer]]s k&ouml;nnen sogar mehrere verschiedene PWM-Signale auf verschiedene Pins erzeugt werden.<br />
:'''Nachteil''': <br />
::* Etwas gr&ouml;sserer Programmaufwand, da der PortPin per Software verändert werden muss.<br />
<br />
==== Hardware PWM ====<br />
:'''Vorteile''':<br />
::* Sehr schnell (Maximal die Quarzfrequenz / Periode)<br />
::* unabhängig vom Programmablauf des AVR<br />
:'''Nachteile''':<br />
::* Je nach AVR k&ouml;nnen nur bestimmte Timer mit bestimmten Ausgangspins daf&uuml;r verwendet werden.<br />
::* belegt den Timer, der für keine weiteren funktionen verwendet werden kann.<br />
<br />
<br />
Beim einem [[ATMega8]] stehen drei Hardware-PWM-Ausg&auml;nge verteilt auf zwei Timer zur Verf&uuml;gung.<br />
<br />
Mit Timer1 können zwei PWM Signale erzeugt werden <br />
(Compare A => OC1A - Pin 15 und Compare B => OC1B - Pin 16).<br />
<br />
Die Auflösung kann auf 8, 9 und 10 Bit eingestellt werden, also max. 1024 Abstufungen.<br />
<br />
Timer2 kann ein PWM-Signal mit einer Auflösung von 8 Bit erzeugen<br />
<br />
(Compare Register => OC2 - Pin 17)<br />
<br />
=== PWM-Ablauf ===<br />
<br />
Das folgende Bild zeigt den Ablauf bei Timer1. Als Taktquelle dient die CPU-Frequenz, dessen Frequenz im Prescaler (Vorteiler) nochmal verkleinert werden kann.<br />
Je nach eingestelltem Wert in den ''Output Compare Registern'' wird der Status des Ausgangs-Pin entsprechend oft umgeschaltet, <br />
und erzeugt somit das PWM-Signal.<br />
<br />
[[Bild:PWM.png|center]]<br />
<br />
<br />
=== Genauere Erklärung ===<br />
<br />
Der Prescaler teilt die Frequenz die vom Quarz kommt!<br />
Bei Teilung 1 geht die vollständige Frequenz zum Timer.<br />
Bei Teilung 8 nur ein Achtel der Quarzfrequenz.<br />
(Also bei 8 MHz Quarz kommen zum Timer dann nur 1 MHz )<br />
Bei Teilung 1024 sind es dann z.B. 8 MHz/1024 = 7,8125kHz <br />
<br />
Der Timer ist hier der Zähler für die PWM.<br />
Er zählt mit der Frequenz, die vom Prescaler kommt, einmal von 0 bis<br />
zu der eingestellten Timerauflösung rauf, dann wieder auf 0 zurück.<br />
(dann wieder von 0 auf Timerauflösung u.s.w.)<br />
Einmal rauf- und runterzählen, ergibt ein Periode.<br />
Die Periode ist gleich die Ausgangsfrequenz des PWM-Signals.<br />
Ausgangsfrequenz = (Quarzfrequenz/Prescale ) /(Timerauflösung*2)<br />
<br />
z.B.: Quarz = 8 MHz ; Prescaler = 1 ; Timer = 8 Bit<br />
ergibt: (8000000Hz/1) / (256*2) = 15,625 kHz<br/><br />
<br />
oder: Quarz = 8 MHz ; Prescaler = 8 ; Timer = 10 Bit<br />
ergibt: (8000000Hz/8) / (1024*2) = 244,14 Hz<br />
<br />
Mit dem Compare Register definiert man nun das Tastverhältnis!<br />
Überall, wo nun der Timer diese Compare Linie schneidet, schaltet der Ausgang!<br />
Beim raufzählen des Timers auf EIN, beim runterzählen auf AUS.<br />
<br />
<br />
<br />
Als Beispiel ein Tastverhältnis von 20%<br />
[[Bild:Compare205.png|center]]<br />
<br />
<br />
Als Beispiel ein Tastverhältnis von 80%<br />
[[Bild:Compare51.png|center]]<br />
<br />
<br />
<br />
Hier sieht man, wie die Signale auf einem Oszilloskop ausschauen.<br />
Oben das Signal von Pin15 (Compare A), unten das von Pin 16 (Compare B)<br />
[[Bild:Osci-PWM-kleiner3.GIF|center]]<br />
<br />
=== Grundprogramm ===<br />
<br />
Hier nun ein Grundprogramm für die Ausgabe von zwei PWM Signalen mit dem Timer1<br />
<br />
<pre><br />
' Hardware PWM mit Timer1<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 4000000<br />
<br />
Config Portb.1 = Output<br />
Config Portb.2 = Output<br />
<br />
Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1<br />
<br />
Do<br />
Compare1a = 205<br />
Compare1b = 51<br />
Loop<br />
<br />
End<br />
</pre><br />
<br />
<br />
''' Erklärung:'''<br />
<pre><br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
</pre><br />
Definiert den Mega8 und den 8MHz Quarz<br />
<br />
<br />
<pre><br />
Config Pinb.1 = Output<br />
Config Pinb.2 = Output<br />
</pre><br />
Definiert die zwei Ausgänge von Timer1 auf Ausgabe.<br/><br />
Pinb.1 = für Compare1a (= Compare A) = Pin 15<br/><br />
Pinb.2 = für Compare1b (= Compare B) = Pin 16<br />
<br />
<br />
<br />
<pre><br />
Config Timer1 = Pwm , Pwm = 8 , Compare A Pwm = Clear Up , Compare B Pwm = Clear Up , Prescale = 1<br />
</pre><br />
;Config Timer1 = Pwm<br />
: Timer1 auf PWM einstellen<br />
<br />
;Pwm = 8 <br />
:Timer Auflösung = 8 Bit einstellen<br />
<br />
;Compare A Pwm = Clear Up:Definiert, wie der Compare A schalten soll. Bei „Clear Up“ schaltet der Ausgang beim erreichen <br />
:des Compare-Wertes zuerst auf High und dann auf Low. Bei „Clear Down“, umgekehrt. <br />
<br />
;Compare B Pwm = Clear Up<br />
:Das gleiche noch mal mit Compare B <br />
<br />
;Prescale = 1<br />
:Hier wird der Prescaler auf 1 eingestellt.<br />
:(Wert 1 heißt, direkte Frequenz vom Quarz zum Timer.)<br />
:Weitere Teilungen, wie z.B.: 8, 64, 256 und 1024 sind möglich.<br />
<br />
<br />
<br />
<pre><br />
Compare1a = 205<br />
Compare1b = 51<br />
</pre> <br />
Hier kann man nun die Werte für das Tastverhältnis, in dem Register Compare1a<br />
und Compare1b übergeben. Oder man kann, statt Compare1a und 1b, auch die Bezeichnungen <br />
Pwm1a und Pwm1b verwenden, Bascom nimmt beides.<br />
<br />
<br />
Mit diesem kurzen Programm, hat man nun zwei [[PWM]] Signale erzeugt, bei dem eines ein Tastverhältnis<br />
von 20% (Compare1a) und das andere 80 % hat. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[Pwm]]<br />
* [[Timer]]<br />
* [[Bascom und Timer]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=9442Bascom und I2C EEprom2006-10-29T17:53:30Z<p>Roberto: /* Beispiel für EEprom 24C256 */</p>
<hr />
<div>== Ansteuern vom I2C EEproms mit Bascom ==<br />
<br />
Der Artikel demonstriert wie man EEPROM Speicherbausteine unter Bascom über den [[I2C]]-Bus anspricht.<br />
<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständnis werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm könnte man aber auch eine Sub-Routine deklarieren, die dann den Schreib/Lesevorgang abwickelt.<br />
<br />
(Eine Sub-Routine braucht aber ca. um die 30Byte pro Aufruf mehr an Speicher, als ein Gosub aufruf. Ich persöhnlich bleibe deshalb doch lieber bei den Gosub's.)<br />
<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für lesen<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C32,24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in High und Low Adressbereich trennen.<br />
(Zuerst High-Adressberreich schreiben und dann Low-Adressbereich) <br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte 1 'sende Speicheradresse High<br />
I2cwbyte B 'sende Speicheradresse Low<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
=== High/Low Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Lesen<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
==Weblinks==<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661 Roboternetz-Thread]<br />
* http://www.eseo.de/i2c.htm<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Diskussion:Codevergleich_AVR-Compiler&diff=8540Diskussion:Codevergleich AVR-Compiler2006-08-21T19:14:26Z<p>Roberto: </p>
<hr />
<div>Hallo Sprinter (schreibe mal hier)<br />
<br />
In Formeln bin ich sehr schlecht, aber was hälst DU davon, wenn man dazu fixe Werte für die Variablen verwendet, einen Einheitlichen Prozessor (z.B. den Mega8) und einen Gleichbeleibenden Quarz.<br />
Dann könnte man die Codes auch untereinander in der Ausführungszeit und dem Speicherverbrauch vergleichen..?<br />
Mann müsste dann aber auch den kompletten Code aufzeigen...<br />
(für C alle Libs..)--[[Benutzer:Roberto|Roberto]] 22:31, 6. Apr 2006 (CEST)<br />
<br />
----<br />
<br />
Die C-Codes habe ich für einen ATmega8 übersetzt. Die Einstellungen für den CPU-Takt haben keinen Einfluss auf die Codeerzeugung (oder etwa bei Bascom??). Den Flash-Verbrauch kann man abzählen oder anzeigen lassen, Zeit- und RAM-Verbrauch sind statisch bestimmbar &ndash; letzeres ist allerdings etwas Arbeit.<br />
<br />
Die Beispiele habe ich als einfache Funktionen gewählt. Einerseits, weil man da schon viel der Eigenheiten eines Compilers erkennen kann. Der erzeugte Code ist wie ein Fingerabdruck und exemplarisch für größere Beispiele. Zudem finde ich, das große Beispiele nicht viel mehr aussagen, und durch meterlange Listings steigt niemand durch und langweilen eher. <br />
<br />
Zudem habe ich Beispiele gewählt, die keine Bibliotheken brauchen. Mehr als der Code, der da steht, wird nicht ausgeführt und ist irrelevant, also auch, wie es "ausserhalb" der Funktionen aussieht. Der einzige externe Bezug ist die Funktion <tt>foo()</tt> bei den Interrupt-Routinen. Welcher Code sich dahinter verbirgt ist egal. Es ist einfach ''irgendeine'' parameterlose Funktion ohne Rückgabewert, die ''irgendwas'' macht und dann zurückkehrt. Genauso ist die Code, aus denen die Beispiele aufgerufen werden, für die Übersetzung unerheblich. Es sind ja keine statischen oder inline-Funktionen.<br />
<br />
--[[Benutzer:SprinterSB|SprinterSB]] 23:20, 6. Apr 2006 (CEST)<br />
<br />
<br />
== sum_n_loop==<br />
<br />
Ich hab mal einen Code in Bascom reingestellt.<br />
Ich glaube nicht dass Dir das Endergebnis so zusagt.<br />
Ist das Ergebnis 45 bei 10 Durchläufen korrekt??<br />
Falls doch, gib mir per PM bescheid, dann mach ich ggf. mehr.<br />
<br />
--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 21:43, 23. Apr 2006 (CEST)--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 21:43, 23. Apr 2006 (CEST)<br />
<br />
----<br />
<br />
Am hex-File sieht man leider nicht viel, weil da vermutlich das genze Programm drinne ist und noch StartUp-Code und so.<br />
<br />
Ich hab mir mal in BASCOM geschaut, aber auf Anhieb hab ich nix gesehen, wie man an den Assembler-Code kommt.<br />
<br />
Hier mal ein Disassemble deines iHex:<br />
<pre>Disassembly of section .sec1:<br />
<br />
00000000 <.sec1>:<br />
0: 12 c0 rjmp .+36 ; 0x26<br />
2: 18 95 reti<br />
4: 18 95 reti<br />
6: 18 95 reti<br />
8: 18 95 reti<br />
a: 18 95 reti<br />
c: 18 95 reti<br />
e: 18 95 reti<br />
10: 18 95 reti<br />
12: 18 95 reti<br />
14: 18 95 reti<br />
16: 18 95 reti<br />
18: 18 95 reti<br />
1a: 18 95 reti<br />
1c: 18 95 reti<br />
1e: 18 95 reti<br />
20: 18 95 reti<br />
22: 18 95 reti<br />
24: 18 95 reti<br />
26: 8f e5 ldi r24, 0x5F ; 95<br />
28: 8d bf out 0x3d, r24 ; 61<br />
2a: c0 e4 ldi r28, 0x40 ; 64<br />
2c: e8 e3 ldi r30, 0x38 ; 56<br />
2e: 4e 2e mov r4, r30<br />
30: 84 e0 ldi r24, 0x04 ; 4<br />
32: 8e bf out 0x3e, r24 ; 62<br />
34: d4 e0 ldi r29, 0x04 ; 4<br />
36: f4 e0 ldi r31, 0x04 ; 4<br />
38: 5f 2e mov r5, r31<br />
3a: ee ef ldi r30, 0xFE ; 254<br />
3c: f3 e0 ldi r31, 0x03 ; 3<br />
3e: a0 e6 ldi r26, 0x60 ; 96<br />
40: b0 e0 ldi r27, 0x00 ; 0<br />
42: 88 27 eor r24, r24<br />
44: 8d 93 st X+, r24<br />
46: 31 97 sbiw r30, 0x01 ; 1<br />
48: e9 f7 brne .-6 ; 0x44<br />
4a: 66 24 eor r6, r6<br />
4c: e0 e6 ldi r30, 0x60 ; 96<br />
4e: f0 e0 ldi r31, 0x00 ; 0<br />
50: fa 93 st -Y, r31<br />
52: ea 93 st -Y, r30<br />
54: 5a 92 st -Y, r5<br />
56: 4a 92 st -Y, r4<br />
58: 8a e0 ldi r24, 0x0A ; 10<br />
5a: 90 e0 ldi r25, 0x00 ; 0<br />
5c: a4 2d mov r26, r4<br />
5e: b5 2d mov r27, r5<br />
60: 8d 93 st X+, r24<br />
62: 9c 93 st X, r25<br />
64: 82 e0 ldi r24, 0x02 ; 2<br />
66: 35 d0 rcall .+106 ; 0xd2<br />
68: 05 d0 rcall .+10 ; 0x74<br />
6a: 24 96 adiw r28, 0x04 ; 4<br />
6c: 82 e0 ldi r24, 0x02 ; 2<br />
6e: 2d d0 rcall .+90 ; 0xca<br />
70: f8 94 cli<br />
72: ff cf rjmp .-2 ; 0x72<br />
74: a8 81 ld r26, Y<br />
76: b9 81 ldd r27, Y+1 ; 0x01<br />
78: 8d 91 ld r24, X+<br />
7a: 9c 91 ld r25, X<br />
7c: a2 e6 ldi r26, 0x62 ; 98<br />
7e: b0 e0 ldi r27, 0x00 ; 0<br />
80: 8d 93 st X+, r24<br />
82: 9c 93 st X, r25<br />
84: aa 81 ldd r26, Y+2 ; 0x02<br />
86: bb 81 ldd r27, Y+3 ; 0x03<br />
88: 37 d0 rcall .+110 ; 0xf8<br />
8a: a2 e6 ldi r26, 0x62 ; 98<br />
8c: b0 e0 ldi r27, 0x00 ; 0<br />
8e: 0d 91 ld r16, X+<br />
90: 1c 91 ld r17, X<br />
92: 00 30 cpi r16, 0x00 ; 0<br />
94: 50 e0 ldi r21, 0x00 ; 0<br />
96: 15 07 cpc r17, r21<br />
98: 14 f0 brlt .+4 ; 0x9e<br />
9a: 09 f0 breq .+2 ; 0x9e<br />
9c: 01 c0 rjmp .+2 ; 0xa0<br />
9e: 12 c0 rjmp .+36 ; 0xc4<br />
a0: a2 e6 ldi r26, 0x62 ; 98<br />
a2: b0 e0 ldi r27, 0x00 ; 0<br />
a4: 1a d0 rcall .+52 ; 0xda<br />
a6: aa 81 ldd r26, Y+2 ; 0x02<br />
a8: bb 81 ldd r27, Y+3 ; 0x03<br />
aa: 0d 91 ld r16, X+<br />
ac: 1c 91 ld r17, X<br />
ae: a2 e6 ldi r26, 0x62 ; 98<br />
b0: b0 e0 ldi r27, 0x00 ; 0<br />
b2: 4d 91 ld r20, X+<br />
b4: 5c 91 ld r21, X<br />
b6: 04 0f add r16, r20<br />
b8: 15 1f adc r17, r21<br />
ba: aa 81 ldd r26, Y+2 ; 0x02<br />
bc: bb 81 ldd r27, Y+3 ; 0x03<br />
be: 0d 93 st X+, r16<br />
c0: 1c 93 st X, r17<br />
c2: e3 cf rjmp .-58 ; 0x8a<br />
c4: 08 95 ret<br />
c6: f8 94 cli<br />
c8: ff cf rjmp .-2 ; 0xc8<br />
ca: 48 1a sub r4, r24<br />
cc: 88 27 eor r24, r24<br />
ce: 58 0a sbc r5, r24<br />
d0: 08 95 ret<br />
d2: 48 0e add r4, r24<br />
d4: 88 27 eor r24, r24<br />
d6: 58 1e adc r5, r24<br />
d8: 08 95 ret<br />
da: ed 91 ld r30, X+<br />
dc: fc 91 ld r31, X<br />
de: 31 97 sbiw r30, 0x01 ; 1<br />
e0: fc 93 st X, r31<br />
e2: ee 93 st -X, r30<br />
e4: 08 95 ret<br />
e6: 31 97 sbiw r30, 0x01 ; 1<br />
e8: f1 f7 brne .-4 ; 0xe6<br />
ea: 08 95 ret<br />
ec: 68 94 set<br />
ee: 62 f8 bld r6, 2<br />
f0: 08 95 ret<br />
f2: e8 94 clt<br />
f4: 62 f8 bld r6, 2<br />
f6: 08 95 ret<br />
f8: 82 e0 ldi r24, 0x02 ; 2<br />
fa: 01 c0 rjmp .+2 ; 0xfe<br />
fc: 84 e0 ldi r24, 0x04 ; 4<br />
fe: 99 27 eor r25, r25<br />
100: 9d 93 st X+, r25<br />
102: 8a 95 dec r24<br />
104: e9 f7 brne .-6 ; 0x100<br />
106: 08 95 ret<br />
</pre><br />
ihex ist leider ein absolutes low-Level-Format, ohne jegliche Symbolinformation...<br />
<br />
Es ist ein ganzes ausführbares Prog, enthält also ausser der Funktion noch zusätzlichen Code und mehr als nur die Funktion:<br />
<pre><br />
0x0000 -- 0x0024: VecTab <br />
0x0026 -- 0x????: Startup-Code<br />
0x???? -- 0x????: Hauptprogramm<br />
0x0058(?) -- 0x006a :X = Sum_n_loop(10) <br />
0x006c - 0x0072: End<br />
0x0074--0x00c4: Sum_n_loop<br />
0x00ca: Helper<br />
0x00da: Helper<br />
0x00d2: Helper<br />
0x00f8: Helper<br />
</pre><br />
Die Helper sind kleine Funktionen, die auf dem Stack und BASCOM-internen GPRs operieren. Zumindest was ich auf die schnelle sehe. Ich kenne BASCOM wie gesagt nicht.<br />
<br />
1+2+3+4+5+6+7+8+9+10 = 55<br />
<br />
Deine 45 kommt daher, daß das Decr zu früh gemacht wird. Es berechnet also nut die Summe 1...N-1.<br />
<br />
Jemand mit besserer Kenntnis von BASCOM könnte den Spaghetti-Code besser auseinanderklabüstern als ich. <br />
<br />
Die Helper gehören eigentlich nicht zum Code der Funktion, auch wenn sie teilweise von dort aufgerufen werden. Bei mehreren Funktionen werden die anderen Funks die SChnippsel auch benutzen, so daß der Code nicht der Summation zuzuschlagen ist (find ich jedenfalls).<br />
<br />
--[[Benutzer:SprinterSB|SprinterSB]] 23:07, 23. Apr 2006 (CEST)<br />
<br />
<br />
----<br />
Problem bei BASCOM ist, dass es nicht compiliert, wenn der Code nicht ausführbar ist.<br />
Ein Objectfile oder sowas wird nicht generiert, ist ja kein C oder Pascal oder sowas.<br />
Also ein Vergleich ist wenn überhaupt am endgültigen Resultat, sprich HEX-File möglich.<br />
Aber das hattest Du vermutlich nicht vor. Das mit der Korrektur des Schleifendurchlauf es<br />
wäre kein akt, aber wenn Du das Endresultat nicht zum Vergleich heranziehen willst, macht es keinen Sinn da noch weitere Energie hinein zu stecken. EIgentlich wäre anstelle "While I > 0" nuer ein "While I >= 0" nötig um die Funktion korrekt zum Ende zu bringen.<br />
<br />
PS: wo ist das denn ein Spagetti-Code? Ist doch schön strukturiert. Nur weil Du die Befehle nicht kennst muss es doch kein Spagetticode sein. Und so schlimm ist es wohl auch nicht. Umgekehrt könnte ich zu C Spagetti sagen, weil mir das nicht zusagt.<br />
<br />
<br />
--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 00:28, 24. Apr 2006 (CEST)<br />
<br />
Mich interessiert der Vergleich eigentlich nicht, aber wenn er denn was nützen soll dann sollte der Code auch vergleichbar sein. Mit Codeauszügen ist das schwierig weil es mühseelig ist den speziellen Code der für die Subroutine zuständig ist herauszupicken, zudem greift Bascom auch in Assember sehr schnell auf Subroutinen im Code zurück, so das dies ohnehin schwierig ist. Es wäre viel einfacher und auch aussagekräftiger wenn das komplette Programm auf beidne Seiten als Assembler aufgelistet würde, so wie es Darwin jetzt oben in Bascom gemacht hat. <br />
Ansonsten würden Benchmarks für bestimmte Aufgaben (Rechenzeit/Codegröße) für viele sicher interessanter sein. <br />
<br />
--[[Benutzer:Frank|Frank]] 01:12, 24. Apr 2006 (CEST)<br />
<br />
<br />
----<br />
Das "Spaghetti-Code" bezog sich auf das Disassemble der hex-Datei, nicht auf die BASIC-Quelle.<br />
<br />
Das "While I >= 0" ist immer noch nicht korrekt. Der erste Wert, der addiert wird, ist dann immer noch N-1 und nicht N. Ausserden würde mit >=0 am Ende eine -1 addiert werden, weil das Decr vor der Summe steht.<br />
<br />
Ein Codevergleich ist ja so was wie ein Benchmark. Und einfache Routinen, die in den Sprachen gleich aussehen (die Summenberechnung sieht in C ja genauso aus wie in BASIC), sind ja im Artikel als Vorschlag drinne. Irgendw muss man ja anfangen. Laufzeitbestimmungen könnte man natürlich auch machen... <br />
<br />
Den Assembler-Code von Darwin sehe ich momentan nicht. Das einzige was ich hab, ist ein HEX-Dump (Maschinen-Code) und ein Assembler-Code aus dem hex. Der Code der Routine kann man schon in etwa zuordnen. Und die kleinen Funktiönchen, die Bascom aufruft, sind wahrscheinlich feste Bausteine, die auch von anderen Funktionen (falls vorhanden) mitverwendet würden.<br />
<br />
----<br />
Das sehe ich nicht so. Ein "Bänschmarg" sollte eigentlich die reíne Rechenleistung wiedergeben. Codeoptimierung ist da was ganz anderes. Zumal ein längerer Code durchaus schneller als ein kompakter Code sein KANN. Manche Befehle benötigen mehr "Ticks" als andere. In Vielen Sprachen ist zwar x=x+1 langsamer und länger als inc x, dies muss aber nicht für alle Befehle gelten und ist ja auch noch kein Compilat, es wird aber auf unterschiedliche Weisen das gleiche Ergebniss erzielt (Das Ziel ist der Weg). Waurm wurde wohl der RISC entwickelt (Reduced InStruction Code). Da muss ma auch mehrere Befehle ausführen als mit einem "NonRISC" System, trozdem sollte das "RISC-System" schneller arbeiten.<br />
<br />
--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 23:43, 26. Apr 2006 (CEST)<br />
<br />
=Fazit?=<br />
Hallo<br />
<br />
Gibt es jetzt darüber eigentlich schon ein Fazit ?<br />
Um wieviel ist C jetzt schneller als Bascom ?<br />
--[[Benutzer:Roberto|Roberto]] 07:42, 10. Aug 2006 (CEST)<br />
<br />
----<br />
<br />
Zunächst mal zur Deiner Frage. Sie wird in dieser Form oder als "Ist C schneller als BASIC?" öfter gestellt. Diese Frage kann nicht beantwortet werden. Bei "C" und "BASIC" handelt es sich um zwei Programmiersprachen. Grundsätzlich ist es für jeden Compiler vorstellbar, daß er den optimalen Assembler-Code zu einer gegeben Quelle findet (wobei man natürlich noch angeben muss, was unter "optimal" zu verstehen ist).<br />
<br />
Hier geht es jedoch nicht um den Vergleich zweier Programmiersprachen, welche man anhand von Attributen/Kriterien wie objektorientiert, aspektorientiert, imperativ, modular, funktional, Befolgung von Standards, Verbreitung, Plattformunabhängigkeit, Möglichkeiten zur Fehlererkennung/-vermeidung, Verifizierbarkeit, Sicherheit/Robustheit etc. vergleichen würde.<br />
<br />
In dem Artikel geht es um einen Vergleich von Compilern, mit welchen Quellcode nach Maschinen- bzw. Assemblercode für AVR übersetzt werden kann, und zwar nur im Hinblick auf den generierten Code.<br />
<br />
Verglichen werden (Stand 08/2006) avr-gcc und BASCOM, wobei auf BASCOM-Seite nur eine einzige Quelle ausgearbeitet wurde, was dadurch erschwert wird, daß BASCOM keinen Assembler-Code erzeugt sondern direkt nach Maschinensprache übersetzt und keine Quellbezüge einfügt.<br />
<br />
Bereits anhand dieses einen Beispiels kann man auf die Arbeitsweise der beiden Compiler zurückschliessen. <br />
<br />
Die Codegröße von 70 Bytes (ohne die Lib-Funktion für den Dekrement) bei BASCOM im Vergleich zu 20 Bytes bei avr-gcc liegt zum großen Teil darin begründet, daß BASCOM Werte nicht in Registern hält, sondern immer wieder aus dem SRAM lesen und schreiben muss. Die dafür notwendigen Befehle ergeben sowohl einen breiteren Code als auch eine längere Laufzeit. Einem Compiler dieses Register-Rechnen beizubringen ist jedoch alles andere als einfach und m.E. kurz- oder mittelfristig in BASCOM nicht zu erwarten.<br />
<br />
Dies hat z.B. zur Folge, daß auch ein Dekrement (eine häufige arithmetische Operation in vielen Anwendungen) auf dem SRAM geschieht. Die lokale Variable <tt>N</tt> lebt im Frame der Funktion (hier als Softstack realisiert), und der Dekrement wird umgesetzt in eine Lib-Funktion und einen Aufruf mit vorheriger Adressberechnung von <tt>N</tt>:<br />
<pre><br />
...<br />
LDD XL,Y + 0<br />
LDD XH,Y + 1<br />
CALL L_Decrement<br />
...<br />
L_Decrement:<br />
LD ZL,X+<br />
LD ZH,X<br />
SBIW ZL,0x0001<br />
ST X,ZH<br />
ST -X,ZL<br />
RET<br />
</pre><br />
Das dauert ca. 20 Takte, im Gegensatz zu den 2 Takten des avr-gcc-Dekrements (<tt>n</tt> lebt im Registerpaar r25:r24)<br />
<pre><br />
sbiw r24, 0x01<br />
</pre><br />
<br />
Erstaunlich finde ich, daß der Vergleich gegen 0. Der abzuprüfende Wert wurde schon nach r17:r16 geladen:<br />
<pre><br />
CPI r16,0x00 ; LOW <> 0 ?<br />
LDI r21,0x00 <br />
CPC r17,r21 ; HIGH <> 0 ? <br />
BRLT L_0x00D6 ; branch lower ->function exit<br />
BREQ L_0x00D6 ; branch equal ->function exit<br />
</pre><br />
Diese häufig benötigte Sequenz könnte mit wenig Aufwand geschickter gestaltet werden (evtl. mit anderem Sprungbefehl), so wie in avr-gcc geschehen (es wird r25:r24 getestet):<br />
<pre><br />
sbiw r24, 0x00<br />
breq .+8<br />
</pre><br />
<br />
Mit Optimierungen ist BASCOM sehr zurückhaltend; in dem Beispiel sind sie nicht erkennbar. avr-gcc kann auf einen ganzen Pool von Optimierungen zurückgreifen, die gcc schon mitbringt.<br />
<br />
Für spezielle und häufig nachgefragte Routinen wie "Zeichen übern UART senden" bringt BASCOM Lib-Funktionen mit. Diese Lib-Funktionen sind in Assembler programmiert und dürften dementsprechender effizienter sein als BASCOM-compiliertes BASIC. Zwar kommt die Effizienz dieser Libs nicht vom BASCOM-Compiler, für einen Anwender, der diese Funktionen benutzt, ist dieser Unterschied jedoch rein akademischer Natur und irrelevant. Solange man nicht selber programmieren muss und viele Funktionen schreibt, bleibt man dann im Rahmen der Lib-Effizienz. <br />
<br />
Momentan ist BASCOM noch in einem Stadium, in dem Compiler-Optimierungen sowohl einen schnelleren auch einen dichteren Code bringen. Ausgefeilte Optimierungsstrategien wie in gcc werden nicht ergriffen. Für einfache Programme wie im AVR-Umfeld üblich dürften Codegröße und Laufzeit mindestens um den Faktor 2 schlechter sein als bei avr-gcc, teilweise auch deutlich darüber. Beschränkt man sich vorwiegend auf BASCOM-Libs, dürfte sich dieses Verhältnis etwas entspannen.<br />
<br />
--[[Benutzer:SprinterSB|SprinterSB]] 15:48, 21. Aug 2006 (CEST)<br />
<br />
Danke für die ausführliche Beschreibung :-) --[[Benutzer:Roberto|Roberto]] 21:14, 21. Aug 2006 (CEST)</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Diskussion:Codevergleich_AVR-Compiler&diff=8516Diskussion:Codevergleich AVR-Compiler2006-08-10T05:42:44Z<p>Roberto: </p>
<hr />
<div>Hallo Sprinter (schreibe mal hier)<br />
<br />
In Formeln bin ich sehr schlecht, aber was hälst DU davon, wenn man dazu fixe Werte für die Variablen verwendet, einen Einheitlichen Prozessor (z.B. den Mega8) und einen Gleichbeleibenden Quarz.<br />
Dann könnte man die Codes auch untereinander in der Ausführungszeit und dem Speicherverbrauch vergleichen..?<br />
Mann müsste dann aber auch den kompletten Code aufzeigen...<br />
(für C alle Libs..)--[[Benutzer:Roberto|Roberto]] 22:31, 6. Apr 2006 (CEST)<br />
<br />
----<br />
<br />
Die C-Codes habe ich für einen ATmega8 übersetzt. Die Einstellungen für den CPU-Takt haben keinen Einfluss auf die Codeerzeugung (oder etwa bei Bascom??). Den Flash-Verbrauch kann man abzählen oder anzeigen lassen, Zeit- und RAM-Verbrauch sind statisch bestimmbar &ndash; letzeres ist allerdings etwas Arbeit.<br />
<br />
Die Beispiele habe ich als einfache Funktionen gewählt. Einerseits, weil man da schon viel der Eigenheiten eines Compilers erkennen kann. Der erzeugte Code ist wie ein Fingerabdruck und exemplarisch für größere Beispiele. Zudem finde ich, das große Beispiele nicht viel mehr aussagen, und durch meterlange Listings steigt niemand durch und langweilen eher. <br />
<br />
Zudem habe ich Beispiele gewählt, die keine Bibliotheken brauchen. Mehr als der Code, der da steht, wird nicht ausgeführt und ist irrelevant, also auch, wie es "ausserhalb" der Funktionen aussieht. Der einzige externe Bezug ist die Funktion <tt>foo()</tt> bei den Interrupt-Routinen. Welcher Code sich dahinter verbirgt ist egal. Es ist einfach ''irgendeine'' parameterlose Funktion ohne Rückgabewert, die ''irgendwas'' macht und dann zurückkehrt. Genauso ist die Code, aus denen die Beispiele aufgerufen werden, für die Übersetzung unerheblich. Es sind ja keine statischen oder inline-Funktionen.<br />
<br />
--[[Benutzer:SprinterSB|SprinterSB]] 23:20, 6. Apr 2006 (CEST)<br />
<br />
<br />
== sum_n_loop==<br />
<br />
Ich hab mal einen Code in Bascom reingestellt.<br />
Ich glaube nicht dass Dir das Endergebnis so zusagt.<br />
Ist das Ergebnis 45 bei 10 Durchläufen korrekt??<br />
Falls doch, gib mir per PM bescheid, dann mach ich ggf. mehr.<br />
<br />
--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 21:43, 23. Apr 2006 (CEST)--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 21:43, 23. Apr 2006 (CEST)<br />
<br />
----<br />
<br />
Am hex-File sieht man leider nicht viel, weil da vermutlich das genze Programm drinne ist und noch StartUp-Code und so.<br />
<br />
Ich hab mir mal in BASCOM geschaut, aber auf Anhieb hab ich nix gesehen, wie man an den Assembler-Code kommt.<br />
<br />
Hier mal ein Disassemble deines iHex:<br />
<pre>Disassembly of section .sec1:<br />
<br />
00000000 <.sec1>:<br />
0: 12 c0 rjmp .+36 ; 0x26<br />
2: 18 95 reti<br />
4: 18 95 reti<br />
6: 18 95 reti<br />
8: 18 95 reti<br />
a: 18 95 reti<br />
c: 18 95 reti<br />
e: 18 95 reti<br />
10: 18 95 reti<br />
12: 18 95 reti<br />
14: 18 95 reti<br />
16: 18 95 reti<br />
18: 18 95 reti<br />
1a: 18 95 reti<br />
1c: 18 95 reti<br />
1e: 18 95 reti<br />
20: 18 95 reti<br />
22: 18 95 reti<br />
24: 18 95 reti<br />
26: 8f e5 ldi r24, 0x5F ; 95<br />
28: 8d bf out 0x3d, r24 ; 61<br />
2a: c0 e4 ldi r28, 0x40 ; 64<br />
2c: e8 e3 ldi r30, 0x38 ; 56<br />
2e: 4e 2e mov r4, r30<br />
30: 84 e0 ldi r24, 0x04 ; 4<br />
32: 8e bf out 0x3e, r24 ; 62<br />
34: d4 e0 ldi r29, 0x04 ; 4<br />
36: f4 e0 ldi r31, 0x04 ; 4<br />
38: 5f 2e mov r5, r31<br />
3a: ee ef ldi r30, 0xFE ; 254<br />
3c: f3 e0 ldi r31, 0x03 ; 3<br />
3e: a0 e6 ldi r26, 0x60 ; 96<br />
40: b0 e0 ldi r27, 0x00 ; 0<br />
42: 88 27 eor r24, r24<br />
44: 8d 93 st X+, r24<br />
46: 31 97 sbiw r30, 0x01 ; 1<br />
48: e9 f7 brne .-6 ; 0x44<br />
4a: 66 24 eor r6, r6<br />
4c: e0 e6 ldi r30, 0x60 ; 96<br />
4e: f0 e0 ldi r31, 0x00 ; 0<br />
50: fa 93 st -Y, r31<br />
52: ea 93 st -Y, r30<br />
54: 5a 92 st -Y, r5<br />
56: 4a 92 st -Y, r4<br />
58: 8a e0 ldi r24, 0x0A ; 10<br />
5a: 90 e0 ldi r25, 0x00 ; 0<br />
5c: a4 2d mov r26, r4<br />
5e: b5 2d mov r27, r5<br />
60: 8d 93 st X+, r24<br />
62: 9c 93 st X, r25<br />
64: 82 e0 ldi r24, 0x02 ; 2<br />
66: 35 d0 rcall .+106 ; 0xd2<br />
68: 05 d0 rcall .+10 ; 0x74<br />
6a: 24 96 adiw r28, 0x04 ; 4<br />
6c: 82 e0 ldi r24, 0x02 ; 2<br />
6e: 2d d0 rcall .+90 ; 0xca<br />
70: f8 94 cli<br />
72: ff cf rjmp .-2 ; 0x72<br />
74: a8 81 ld r26, Y<br />
76: b9 81 ldd r27, Y+1 ; 0x01<br />
78: 8d 91 ld r24, X+<br />
7a: 9c 91 ld r25, X<br />
7c: a2 e6 ldi r26, 0x62 ; 98<br />
7e: b0 e0 ldi r27, 0x00 ; 0<br />
80: 8d 93 st X+, r24<br />
82: 9c 93 st X, r25<br />
84: aa 81 ldd r26, Y+2 ; 0x02<br />
86: bb 81 ldd r27, Y+3 ; 0x03<br />
88: 37 d0 rcall .+110 ; 0xf8<br />
8a: a2 e6 ldi r26, 0x62 ; 98<br />
8c: b0 e0 ldi r27, 0x00 ; 0<br />
8e: 0d 91 ld r16, X+<br />
90: 1c 91 ld r17, X<br />
92: 00 30 cpi r16, 0x00 ; 0<br />
94: 50 e0 ldi r21, 0x00 ; 0<br />
96: 15 07 cpc r17, r21<br />
98: 14 f0 brlt .+4 ; 0x9e<br />
9a: 09 f0 breq .+2 ; 0x9e<br />
9c: 01 c0 rjmp .+2 ; 0xa0<br />
9e: 12 c0 rjmp .+36 ; 0xc4<br />
a0: a2 e6 ldi r26, 0x62 ; 98<br />
a2: b0 e0 ldi r27, 0x00 ; 0<br />
a4: 1a d0 rcall .+52 ; 0xda<br />
a6: aa 81 ldd r26, Y+2 ; 0x02<br />
a8: bb 81 ldd r27, Y+3 ; 0x03<br />
aa: 0d 91 ld r16, X+<br />
ac: 1c 91 ld r17, X<br />
ae: a2 e6 ldi r26, 0x62 ; 98<br />
b0: b0 e0 ldi r27, 0x00 ; 0<br />
b2: 4d 91 ld r20, X+<br />
b4: 5c 91 ld r21, X<br />
b6: 04 0f add r16, r20<br />
b8: 15 1f adc r17, r21<br />
ba: aa 81 ldd r26, Y+2 ; 0x02<br />
bc: bb 81 ldd r27, Y+3 ; 0x03<br />
be: 0d 93 st X+, r16<br />
c0: 1c 93 st X, r17<br />
c2: e3 cf rjmp .-58 ; 0x8a<br />
c4: 08 95 ret<br />
c6: f8 94 cli<br />
c8: ff cf rjmp .-2 ; 0xc8<br />
ca: 48 1a sub r4, r24<br />
cc: 88 27 eor r24, r24<br />
ce: 58 0a sbc r5, r24<br />
d0: 08 95 ret<br />
d2: 48 0e add r4, r24<br />
d4: 88 27 eor r24, r24<br />
d6: 58 1e adc r5, r24<br />
d8: 08 95 ret<br />
da: ed 91 ld r30, X+<br />
dc: fc 91 ld r31, X<br />
de: 31 97 sbiw r30, 0x01 ; 1<br />
e0: fc 93 st X, r31<br />
e2: ee 93 st -X, r30<br />
e4: 08 95 ret<br />
e6: 31 97 sbiw r30, 0x01 ; 1<br />
e8: f1 f7 brne .-4 ; 0xe6<br />
ea: 08 95 ret<br />
ec: 68 94 set<br />
ee: 62 f8 bld r6, 2<br />
f0: 08 95 ret<br />
f2: e8 94 clt<br />
f4: 62 f8 bld r6, 2<br />
f6: 08 95 ret<br />
f8: 82 e0 ldi r24, 0x02 ; 2<br />
fa: 01 c0 rjmp .+2 ; 0xfe<br />
fc: 84 e0 ldi r24, 0x04 ; 4<br />
fe: 99 27 eor r25, r25<br />
100: 9d 93 st X+, r25<br />
102: 8a 95 dec r24<br />
104: e9 f7 brne .-6 ; 0x100<br />
106: 08 95 ret<br />
</pre><br />
ihex ist leider ein absolutes low-Level-Format, ohne jegliche Symbolinformation...<br />
<br />
Es ist ein ganzes ausführbares Prog, enthält also ausser der Funktion noch zusätzlichen Code und mehr als nur die Funktion:<br />
<pre><br />
0x0000 -- 0x0024: VecTab <br />
0x0026 -- 0x????: Startup-Code<br />
0x???? -- 0x????: Hauptprogramm<br />
0x0058(?) -- 0x006a :X = Sum_n_loop(10) <br />
0x006c - 0x0072: End<br />
0x0074--0x00c4: Sum_n_loop<br />
0x00ca: Helper<br />
0x00da: Helper<br />
0x00d2: Helper<br />
0x00f8: Helper<br />
</pre><br />
Die Helper sind kleine Funktionen, die auf dem Stack und BASCOM-internen GPRs operieren. Zumindest was ich auf die schnelle sehe. Ich kenne BASCOM wie gesagt nicht.<br />
<br />
1+2+3+4+5+6+7+8+9+10 = 55<br />
<br />
Deine 45 kommt daher, daß das Decr zu früh gemacht wird. Es berechnet also nut die Summe 1...N-1.<br />
<br />
Jemand mit besserer Kenntnis von BASCOM könnte den Spaghetti-Code besser auseinanderklabüstern als ich. <br />
<br />
Die Helper gehören eigentlich nicht zum Code der Funktion, auch wenn sie teilweise von dort aufgerufen werden. Bei mehreren Funktionen werden die anderen Funks die SChnippsel auch benutzen, so daß der Code nicht der Summation zuzuschlagen ist (find ich jedenfalls).<br />
<br />
--[[Benutzer:SprinterSB|SprinterSB]] 23:07, 23. Apr 2006 (CEST)<br />
<br />
<br />
----<br />
Problem bei BASCOM ist, dass es nicht compiliert, wenn der Code nicht ausführbar ist.<br />
Ein Objectfile oder sowas wird nicht generiert, ist ja kein C oder Pascal oder sowas.<br />
Also ein Vergleich ist wenn überhaupt am endgültigen Resultat, sprich HEX-File möglich.<br />
Aber das hattest Du vermutlich nicht vor. Das mit der Korrektur des Schleifendurchlauf es<br />
wäre kein akt, aber wenn Du das Endresultat nicht zum Vergleich heranziehen willst, macht es keinen Sinn da noch weitere Energie hinein zu stecken. EIgentlich wäre anstelle "While I > 0" nuer ein "While I >= 0" nötig um die Funktion korrekt zum Ende zu bringen.<br />
<br />
PS: wo ist das denn ein Spagetti-Code? Ist doch schön strukturiert. Nur weil Du die Befehle nicht kennst muss es doch kein Spagetticode sein. Und so schlimm ist es wohl auch nicht. Umgekehrt könnte ich zu C Spagetti sagen, weil mir das nicht zusagt.<br />
<br />
<br />
--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 00:28, 24. Apr 2006 (CEST)<br />
<br />
Mich interessiert der Vergleich eigentlich nicht, aber wenn er denn was nützen soll dann sollte der Code auch vergleichbar sein. Mit Codeauszügen ist das schwierig weil es mühseelig ist den speziellen Code der für die Subroutine zuständig ist herauszupicken, zudem greift Bascom auch in Assember sehr schnell auf Subroutinen im Code zurück, so das dies ohnehin schwierig ist. Es wäre viel einfacher und auch aussagekräftiger wenn das komplette Programm auf beidne Seiten als Assembler aufgelistet würde, so wie es Darwin jetzt oben in Bascom gemacht hat. <br />
Ansonsten würden Benchmarks für bestimmte Aufgaben (Rechenzeit/Codegröße) für viele sicher interessanter sein. <br />
<br />
--[[Benutzer:Frank|Frank]] 01:12, 24. Apr 2006 (CEST)<br />
<br />
<br />
----<br />
Das "Spaghetti-Code" bezog sich auf das Disassemble der hex-Datei, nicht auf die BASIC-Quelle.<br />
<br />
Das "While I >= 0" ist immer noch nicht korrekt. Der erste Wert, der addiert wird, ist dann immer noch N-1 und nicht N. Ausserden würde mit >=0 am Ende eine -1 addiert werden, weil das Decr vor der Summe steht.<br />
<br />
Ein Codevergleich ist ja so was wie ein Benchmark. Und einfache Routinen, die in den Sprachen gleich aussehen (die Summenberechnung sieht in C ja genauso aus wie in BASIC), sind ja im Artikel als Vorschlag drinne. Irgendw muss man ja anfangen. Laufzeitbestimmungen könnte man natürlich auch machen... <br />
<br />
Den Assembler-Code von Darwin sehe ich momentan nicht. Das einzige was ich hab, ist ein HEX-Dump (Maschinen-Code) und ein Assembler-Code aus dem hex. Der Code der Routine kann man schon in etwa zuordnen. Und die kleinen Funktiönchen, die Bascom aufruft, sind wahrscheinlich feste Bausteine, die auch von anderen Funktionen (falls vorhanden) mitverwendet würden.<br />
<br />
----<br />
Das sehe ich nicht so. Ein "Bänschmarg" sollte eigentlich die reíne Rechenleistung wiedergeben. Codeoptimierung ist da was ganz anderes. Zumal ein längerer Code durchaus schneller als ein kompakter Code sein KANN. Manche Befehle benötigen mehr "Ticks" als andere. In Vielen Sprachen ist zwar x=x+1 langsamer und länger als inc x, dies muss aber nicht für alle Befehle gelten und ist ja auch noch kein Compilat, es wird aber auf unterschiedliche Weisen das gleiche Ergebniss erzielt (Das Ziel ist der Weg). Waurm wurde wohl der RISC entwickelt (Reduced InStruction Code). Da muss ma auch mehrere Befehle ausführen als mit einem "NonRISC" System, trozdem sollte das "RISC-System" schneller arbeiten.<br />
<br />
--[[Benutzer:Darwin.nuernberg|Darwin.nuernberg]] 23:43, 26. Apr 2006 (CEST)<br />
<br />
Hallo<br />
<br />
Gibt es jetzt darüber eigentlich schon ein Fazit ?<br />
Um wieviel ist C jetzt schneller als Bascom ?<br />
--[[Benutzer:Roberto|Roberto]] 07:42, 10. Aug 2006 (CEST)</div>Robertohttps://rn-wissen.de/wiki/index.php?title=C-Tutorial&diff=8131C-Tutorial2006-07-05T12:05:20Z<p>Roberto: /* Strukturen */</p>
<hr />
<div>Ein kurzer Einblick in die Programmiersprache C<br />
=Allgemeines=<br />
C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.<br />
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.<br />
<br />
C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu lediglich einen anderen Compiler, und Inline-Assembler Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden. <br />
<br />
==Geschichte==<br />
;1971: C wird entwickelt<br />
;1978: Kernighan und Ritchie definieren die Sprache.<br />
;1983: ANSI und ISO standardisieren C.<br />
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.<br />
<br />
=Aufbau eines C-Programmes=<br />
<!-- <br />
<br />
C-Programme haben keinen fixen Aufbau wie z.B. Pascal. Es gibt zwar gewisse Regeln, aber sonst sind dem Programmierer alle Freiheiten überlassen. Der folgende "Beispiel-Aufbau" ist daher nicht zwingend und kann durchaus verändert werden.<br />
<br />
Natürlich haben C-Programme einen fixen Aufbau! Ebenso wie Pascal-Programme auch unterliegen sie einer strikten Grammatik! <br />
Auskommentiert --[[Benutzer:SprinterSB|SprinterSB]] 10:23, 17. Feb 2006 (CET)<br />
--><br />
Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau. <br />
<pre><br />
#include <stdio.h><br />
<br />
int Zahl1;<br />
char Zeichen1;<br />
<br />
int main (void)<br />
{<br />
int zahl2;<br />
<br />
/* Anweisungen */<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Beschreibung (die Erklärungen folgen): <br />
<br />
;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.<br />
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.<br />
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert. <br />
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.<br />
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.<br />
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert. <br />
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.<br />
;return 0;: Gibt den Wert&nbsp;0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.<br />
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.<br />
<br />
=Das Hauptprogramm main=<br />
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm. <br />
<br />
Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer &ndash; üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt. <br />
<br />
Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!<br />
<pre><br />
/* <br />
* void Definition von main ist nur beim Controller üblich<br />
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main<br />
* kein Fehler/Warnung erzeugt wird. <br />
*/<br />
void main (void)<br />
{<br />
...<br />
}<br />
</pre><br />
<br />
=Blöcke=<br />
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung.<br />
Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende": <br />
<br />
<pre><br />
int main (void)<br />
{ /* der Block "main" beginnt */<br />
int zahl;<br />
<br />
{ /* ein Block beginnt */<br />
/* hier können Deklarationen und Anweisungen stehen */<br />
} /* der Block endet */<br />
<br />
return 0;<br />
} /* "main" endet */<br />
</pre><br />
<br />
'''Bemerkung:''' <br />
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!<br />
<br />
=Datentypen=<br />
==Elementare Datentypen==<br />
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.<br />
<br />
;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!<br />
<br />
===int, char, short, long (ganze Zahlen)===<br />
In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen. <br />
<br />
Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann reicht der Wertebereich von <tt>-2<sup>''b''-1</sup></tt> bis zu <tt>2<sup>''b''-1</sup>-1</tt>.<br />
<br />
Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2<sup>''b''</sup>-1</tt>, wenn der Typ ''b'' Bits breit ist.<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs<br />
|- <br />
| 8 || <tt>char</tt> <br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -128<br />0<br />
| align="right" | 127<br />255<br />
|- <br />
| 16 || <tt>short</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -32.768<br />0<br />
| align="right" | 32.767<br />65.535<br />
|- <br />
| 32 || <tt>long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -2.147.483.648<br />0<br />
| align="right" | 2.147.483.647<br />4.294.967.295<br />
|- <br />
| 64 || <tt>long long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -9.223.372.036.854.775.808<br />0<br />
| align="right" | 9.223.372.036.854.775.807<br />18.446.744.073.709.551.615<br />
|-<br />
|8, 16, 32, 64<br/><br />
| <tt>int</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
|plattform-/compilerabhängig<br />
|plattform-/compilerabhängig<br />
|}<br />
</center><br />
<br />
==== Boolean (Logische Variablen)====<br />
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.<br />
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.<br />
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert&nbsp;1 haben muß. Sie muß lediglich ungleich&nbsp;0 sein!<br />
<br />
====char (Zeichen)====<br />
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen. <br />
<br />
Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!<br />
<br />
===float, double (Gleitkommazahlen)===<br />
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. <br />
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.<br />
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.<br />
<br />
===void===<br />
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.<br />
<br />
==Zeiger==<br />
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''. <br />
<br />
Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein&nbsp;<tt>&</tt> voranstellt. Die Umkehrung davon &ndash; also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist &ndash; erledigt ein vorgestellter&nbsp;<tt>*</tt>. Der Operator &nbsp;<tt>*</tt> gibt also den ''Inhalt'' der Adresse.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int * zeiger;<br />
int zahl;<br />
<br />
zeiger = &zahl;<br />
*zeiger = 12;<br />
<br />
printf ("%d = %d", zahl, *zeiger);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der&nbsp;<tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:<br />
int * zeiger, zahl;<br />
<br />
Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator&nbsp;<tt>&</tt> von <tt>zahl</tt>:<br />
zeiger = &zahl; <br />
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>). <br />
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.<br />
<br />
==Zusammengesetzte Datentypen==<br />
===Arrays===<br />
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays &ndash; teilweise auch als ''Felder'' bezeichnet &ndash; zu verwenden.<br />
<br />
In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> arbeiten!<br />
<br />
'''Syntax:''' Datentyp Variablenname[Anzahl]<br />
<br />
Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für 3 Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes. <br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int i;<br />
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */<br />
<br />
for (i=0; i<10; i++)<br />
{<br />
printf ("Bitte Zahl %d eingeben: ", i);<br />
scanf ("%d", & zahlen[i]);<br />
printf ("\n");<br />
}<br />
printf ("Super!\n");<br />
<br />
for (i=0; i<10; i++) <br />
printf ("Zahl %d ist: %d\n", i, zahlen[i]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen:''' <br />
Zuerst wird ein 10 int-Variablen großes Array angelegt. <br />
In dieses wird nun der Reihe nach 10 Zahlen eingelesen. <br />
Anschließend werden alle 10 Zahlen ausgegeben. <br />
<br />
{{FarbigerRahmen|<br />
'''Merke:'''<br />
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!<br />
}}<br />
<br />
===Strings (Zeichenketten)===<br />
Ein String ist nichts anderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.<br />
<br />
Die Definition eines Strings erfolgt also genauso wie bei Arrays:<br />
char string[21];<br />
<br />
Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert". <br />
<br />
Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.<br />
<br />
===Mehrdimensionale Arrays===<br />
Manchmal benötigt man mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.<br />
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:<br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int x,y;<br />
int feld[3][5];<br />
<br />
for (x=0; x<3; x++) <br />
{<br />
for (y=0; y<5; y++)<br />
{<br />
printf ("Feldwert x: %d, y: %d ", x, y);<br />
scanf ("%d", & feld[x][y]);<br />
printf ("\n");<br />
}<br />
}<br />
<br />
for(x=0; x<3; x++) <br />
for (y=0; y<5; y++) <br />
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Erklärung:''' <br />
<br />
Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt. <br />
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>. <br />
Zum Schluß werden alle Werte noch einmal ausgegeben.<br />
<br />
===Strukturen===<br />
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden: <br />
<br />
<pre><br />
struct Person <br />
{<br />
int id;<br />
char vname[20], nname[20];<br />
char telnr[15];<br />
int alter;<br />
};<br />
</pre><br />
<br />
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein. <br />
Dann werden in dieser Struktur fünf Komponenten angelegt: drei Strings und zwei <tt>int</tt>. <br />
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach <br />
struct Person Variablenname;<br />
an. <br />
<br />
Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:<br />
<pre><br />
struct Person hubert, klaus;<br />
<br />
hubert.alter = 32;<br />
klaus.alter = hubert.alter + 1;<br />
</pre><br />
<br />
===Unions===<br />
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.<br />
<pre><br />
union Daten <br />
{<br />
int id;<br />
<br />
struct u_double<br />
{<br />
int id;<br />
double wert;<br />
};<br />
<br />
struct Person u_person;<br />
<br />
struct u_pointer<br />
{<br />
int id;<br />
union Daten * p1;<br />
union Daten * p2;<br />
};<br />
};<br />
<br />
union Daten data;<br />
</pre><br />
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_double</tt>, <tt>u_person</tt> und <tt>u_pointer</tt>. Die Große der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden.<br />
<br />
Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:<br />
<pre><br />
typedef union<br />
{<br />
unsigned long as_long;<br />
unsignen chat as_byte[4];<br />
} data32_t;<br />
</pre><br />
Dies überlagert einen <tt>unsigned long</tt> &ndash; also eine 32-Bit-Zahl &ndash; mit vier Bytes.<br />
<pre><br />
data32_t wert;<br />
<br />
wert.as_long = 0x12345678;<br />
wert.as_byte[0] = 0xab;<br />
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */<br />
</pre><br />
<br />
=Variablen=<br />
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.<br />
<br />
==Variablennamen==<br />
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.<br />
<br />
Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.<br />
==Anlegen von Variablen==<br />
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung! <br />
<pre><br />
int Zahl1, Zahl2;<br />
char Zeichen;<br />
<br />
int main (void)<br />
{<br />
float gleitZahl;<br />
/* Anweisungen */<br />
<br />
return 0;<br />
}<br />
</pre><br />
;Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].<br />
<br />
==Zuweisungen==<br />
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]]. <br />
<pre><br />
int main (void)<br />
{<br />
int zahl1, zahl2 = 12;<br />
char zeichen1 = 'A';<br />
<br />
zahl1 = 52;<br />
zeichen1 = zeichen1 + 1; <br />
<br />
return 0;<br />
}<br />
</pre><br />
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>). <br />
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen. <br />
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.<br />
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.<br />
<br />
==Zuweisungen bei float==<br />
Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt: <br />
floatVariable = 3.14;<br />
Zusätzlich kann eine Zehnerpotenz angegeben werden:<br />
floatVariable2 = -1.234E-6;<br />
Dadurch wird der erst Wert mit 10<sup><tt>-</tt>6</sup> multipliziert, der Wert der Variablen ist also <br />
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.<br />
<br />
==Zuweisungen bei logischen Variablen==<br />
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr". <br />
intVariable = !0; /* entspricht "wahr" */<br />
intVariable = 0; /* entspricht "unwahr" */<br />
<br />
==Vergleich von Variablen==<br />
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln: <br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|}<br />
</center><br />
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl. <br />
intVariable = zahl1 <= zahl2;<br />
das komplette Beispiel zeigt es deutlicher:<br />
<pre><br />
int i;<br />
int z1, z2;<br />
<br />
z1 = 5;<br />
z2 = 100;<br />
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */<br />
<br />
printf ("Ergebnis: %d\n", i);<br />
</pre><br />
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").<br />
<br />
==Konstanten==<br />
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:<br />
const ''datentyp'' name = value; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. <br />
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.<br />
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit<br />
* ((float*) &PI) = 2;<br />
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.<br />
<br />
Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist<br />
void foo (const char * str, ...);<br />
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.<br />
<br />
Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:<br />
void foo (char * const str, ...);<br />
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>. Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim&nbsp;<tt>*</tt> auf: Steht das <tt>const</tt> links vom&nbsp;<tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides &ndash; also den Zeiger und sein Ziel &ndash; als konstant zu markieren.<br />
<br />
==Gültigkeitsbereich==<br />
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln: <br />
<br />
;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.<br />
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.<br />
<br />
==Speicherklassen==<br />
Jede Variable in C gehört zu einer bestimmten Speicherklasse<br />
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.<br />
;<tt>extern</tt>: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].<br />
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.<br />
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable &ndash; falls möglich &ndash; als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!<br />
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.<br />
<br />
=Ausdrücke=<br />
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.<br />
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.<br />
<br />
Einfache Beispiele für Ausdrücke sind also z.B.:<br />
1<br />
a<br />
'a'<br />
1 + a<br />
a == 1<br />
<br />
Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.<br />
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,<br />
und wei man damit neue Ausdrücke aufbauen kann.<br />
<br />
==Lvalues==<br />
<br />
Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.<br />
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.<br />
<br />
Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:<br />
a = 1;<br />
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie<br />
a+1 = 2;<br />
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":<br />
"ungültiger Wert in Zuweisung"<br />
<br />
Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante&nbsp;4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung&nbsp;<tt>*</tt> wird an die Adresse&nbsp;4 im Speicher eine&nbsp;3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.<br />
* ((unsigned int *) 4) = 3;<br />
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue<br />
<br />
==Logische (boolsche) Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a &amp;&amp; b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr<br />
|-<br />
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr<br />
|-<br />
|<tt>a == b</tt> || gleich<br />
|-<br />
|<tt>a != b</tt> || ungleich<br />
|-<br />
|<tt>a <= b</tt> || kleiner oder gleich<br />
|-<br />
|<tt>a < b</tt> || kleiner als<br />
|-<br />
|<tt>a >= b</tt> || glösser oder gleich<br />
|-<br />
|<tt>a > b</tt> || grösser als<br />
|-<br />
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa<br />
|}<br />
</center><br />
<br />
Eine interessante Eigenheit der Operatoren <tt>&amp;&amp;</tt> und <tt>||</tt> ist, dass<br />
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden<br />
dabei immer von links nach rechts ausgewertet.<br />
<br />
Beispiel:<br />
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */<br />
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */<br />
<br />
<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,<br />
die eine aufwändige Operation durchführt.<br />
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder<br />
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.<br />
<br />
Wo ist also der Unterschied?<br><br />
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,<br />
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.<br />
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte<br />
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.<br />
<br />
==Arithmetische Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a + b</tt> || Summe (Addition)<br />
|-<br />
|<tt>a - b</tt> || Differenz (Subtraktion)<br />
|-<br />
|<tt>a * b</tt> || Produkt (Multiplikation)<br />
|-<br />
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)<br />
|-<br />
|<tt>a % b</tt> || Rest bei Division (Modulo)<br />
|-<br />
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)<br />
|}<br />
</center><br />
==Bit-Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a & b</tt> || bitweise und (and)<br />
|-<br />
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)<br />
|-<br />
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)<br />
|-<br />
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)<br />
|}<br />
</center><br />
==Index-Operator bei Arrays==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a<br />
|}<br />
</center><br />
<br />
Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:<br />
<br />
# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein<br />
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)<br />
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!<br />
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung<br />
<br />
==Komponenten-Auswahl bei Structs und Unions==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a<br />
|}<br />
</center><br />
<br />
==Adress-Operator und Dereferenzierung==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>&amp;a</tt> || Speicheradresse der Variablen <tt>a</tt><br />
|-<br />
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht<br />
|-<br />
||<tt>a-&gt;b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht<br />
|}<br />
</center><br />
<br />
Der Adressoperator & kann auf Variablen angewendet werden und<br />
gibt die Startadresse der Variablen im Speicher zurück.<br />
<br />
Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält<br />
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der<br />
an dieser Adresse steht, wird der Operator * vorangestellt.<br />
<br />
Beispiel:<br />
<pre><br />
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */<br />
<br />
/* z ist ein Zeiger auf eine Integervariable und enthält somit<br />
die Speicheradresse einer Integervariablen<br />
*/<br />
int *z; <br />
<br />
/* Verwendung des Adressoperators... */<br />
z = &x; /* weise z die Speicheradresse von x zu */<br />
<br />
/* Verwendung der Dereferenzierung */<br />
/* erhöhe den Wert, der bei Adresse z steht um eins */<br />
*z = *z + 1;<br />
<br />
/* da z auf x zeigt, hat auch x jetzt den Wert 6 */<br />
</pre><br />
<br />
Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff<br />
auf ein Element eine abkürzende Schreibweise möglich:<br />
<br />
Statt <br />
(*strukturZeiger).element<br />
kann geschrieben werden<br />
strukturZeiger->element<br />
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch<br />
auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu<br />
einer Änderung '''irgendeiner''' Speicherstelle:<br />
<br />
<pre><br />
int *z; /* z ist ein Zeiger auf einen Integer */<br />
<br />
/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.<br />
z enthält irgendeine(!) Adresse<br />
*/<br />
<br />
/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */<br />
*z = *z + 1;<br />
</pre><br />
<br />
Viele C-Compiler (z.B. gcc) erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!<br />
}}<br />
<br />
==Cast-Operator==<br />
<br />
Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.<br />
<br />
Um zum Beispiel aus einem Float ein Integer zu machen:<br />
var = (int) 5.60;<br />
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.<br />
<br />
Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:<br />
int * addr;<br />
addr = (int*) 0x1234;<br />
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder<br />
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in<br />
eine Zahl oder umgekehrt zu wandeln:<br />
<br />
<pre><br />
#include <stdio.h><br />
int main(int argc, char ** argv)<br />
{<br />
char text[] = "5.6";<br />
int zahl = (int)text;<br />
<br />
printf("%d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator<br />
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.<br />
}}<br />
<br />
==Komma Operator==<br />
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.<br />
Die Auswertung erfolgt von links nach rechts.<br />
<br />
Solche Konstrukte sieht man manchmal in Abfragen wie<br />
FILE *file;<br />
if (file = fopen ("foo.exe", "r"), file != NULL)<br />
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,<br />
wenn <tt>file</tt> nicht der Nullpointer ist.<br />
<br />
==Zuweisungen und Operatoren mit Nebeneffekt==<br />
===Bedingte Zuweisung===<br />
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;<br />
<br />
<!--<br />
Kein ANSI-C<br />
--[[Benutzer:SprinterSB|SprinterSB]] 17:15, 29. Jun 2006 (CEST)<br />
==Blöcke==<br />
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.<br />
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks. <br />
Der Block muss un runden Klammern stehen:<br />
int sum;<br />
sum = ({<br />
int i, s = 0;<br />
for (i=1; i<= 100; i++)<br />
s += i;<br />
s;<br />
});<br />
<br />
Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc, <br />
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer<br />
Instruktion nicht machbar wäre:<br />
<pre><br />
#define PSTR(s) \<br />
({ \ <br />
static char __c[] PROGMEM = (s); \<br />
__c; \<br />
})<br />
</pre><br />
--><br />
<br />
==Reihenfolge der Auswertung==<br />
<br />
=Kontrollanweisungen=<br />
<br />
==Boolsche Logik==<br />
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird). <br />
<br />
b1= b2 && b3;<br />
<br />
<br />
Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).<br />
<br />
<br />
b1= b2 || b3;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.<br />
<br />
<br />
b1= !b2;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".<br />
<br />
==<tt>if</tt>-Anweisung==<br />
Syntax: IF (Bedingung) Anweisung;<br />
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:<br />
<br />
[[bild:ifthenelse.png]]<br />
<br />
Und in C schreibt man:<br />
<pre><br />
if (Bedingung) /* WENN */<br />
{ /* DANN */<br />
Anweisung1;<br />
Anweisung2;<br />
...<br />
}<br />
else<br />
{ /* SONST */<br />
Anweisung3;<br />
Anweisung4;<br />
...<br />
}<br />
</pre><br />
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt. <br />
<br />
Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki><br />
<br />
<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki><br />
<br />
<br />
Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.<br />
}}<br />
<br />
==<tt>switch</tt>-Anweisung==<br />
Syntax: <br />
<pre><br />
switch(ausdruck) {<br />
case wert1:<br />
Anweisungen1...<br />
case wert2:<br />
Anweisungen2...<br />
case wert3:<br />
Anweisungen3...<br />
...<br />
default:<br />
Anweisungen4...<br />
}<br />
</pre><br />
<br />
Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter<br />
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der<br />
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt><br />
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.<br />
<br />
<b>Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines<br />
<tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!</b><br />
<br />
Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.<br />
Der <tt>default</tt>-Abschnitt ist optional, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,<br />
wenn er verwendet wird.<br />
<br />
<br />
==Schleifen==<br />
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.<br> <br />
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird. <br />
<br />
===<tt>while</tt>-Schleife===<br />
'''Syntax:''' while (Bedingung) { Anweisung; }<br />
<br />
Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block! <br />
<br />
<pre><br />
Zahl1=0;<br />
while (Zahl1<3)<br />
{<br />
Zahl1=Zahl1+1;<br />
Zahl2=Zahl2*2;<br />
}<br />
</pre><br />
<br />
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.<br />
===<tt>do</tt>-<tt>while</tt>-Schleife===<br />
'''Syntax:''' do { Anweisung; }while (Bedingung);<br />
<br />
Die DO WHILE-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird <br />
<br />
<pre><br />
int i=2;<br />
do <br />
{<br />
i = i*i; /* i quadrieren */<br />
printf ("i = %d\n", i);<br />
}<br />
while (i < 20);<br />
</pre><br />
<br />
Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.<br />
<br />
===<tt>for</tt>-Schleife===<br />
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }<br />
<br />
Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.<br />
<br />
Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.<br />
<br />
Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet. <br />
<br />
<pre><br />
int lauf;<br />
int summe = 0;<br />
<br />
for (lauf = 1; lauf <= 10; lauf = lauf+2 ) <br />
{<br />
summe = summe + lauf;<br />
}<br />
</pre><br />
Das Äquivalent als <tt>while</tt>-Schleife:<br />
<pre><br />
int lauf = 1; /* Anfangswerte */<br />
int summe = 0;<br />
<br />
while (lauf <= 10) /* Bedingung */<br />
{<br />
summe = summe + lauf;<br />
lauf += 2; /* Inkrement */<br />
}<br />
</pre><br />
<br />
<br />
In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.<br />
<br />
'''Erklärung:''' <br />
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. <br />
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. <br />
<tt>lauf = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um&nbsp;2 erhöht wird.<br />
<br />
=Ein- und Ausgabe=<br />
<br />
==Bildschirm-Ausgabe==<br />
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.<br />
<br />
Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, </tt>char</tt>, <tt>double</tt>...) sein! <br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int zahl1 = 12;<br />
char zeichen1 = 'A';<br />
<br />
printf ("Das ist Text, und er wird als solcher ausgegeben. \n");<br />
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile. <br />
<br />
Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus. <br />
<br />
In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert. <br />
<br />
Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen! <br />
<br />
==Tastatur-Eingabe==<br />
<br />
Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.<br />
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>: <br />
<br />
<pre><br />
int zahl1;<br />
char zeichen1;<br />
<br />
printf ("Bitte geben Sie eine Zahl ein: ");<br />
scanf ("%d", &zahl1);<br />
printf ("Geben Sie einen Zeichen ein: ");<br />
scanf ("%c", &zeichen1);<br />
</pre><br />
<br />
Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.<br />
<br />
Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!<br />
<br />
Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference"). <br />
<br />
<br />
=Allgemeines zu Unterprogrammen=<br />
Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen.<br />
Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen: <br />
<br />
==Funktionen==<br />
'''Syntax:''' Rückgabe-Typ Name(Parameterliste);<br />
<br />
Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln: <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int hoch2 (int param1)<br />
{<br />
int zahl;<br />
zahl = param1 * param1;<br />
return zahl;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl1, ergebnis;<br />
<br />
printf ("Bitte Zahl eingeben: ");<br />
scanf ("%d",&zahl1);<br />
<br />
ergebnis = hoch2 (zahl1);<br />
<br />
printf ("%d hoch 2 = %d\n",zahl1, ergebnis);<br />
printf ("5 hoch 2 = %d\n", hoch2(5));<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. <br />
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. <br />
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.<br />
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. <br />
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert. <br />
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an<br />
variable = Funktion (Parameter);<br />
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile). <br />
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.<br />
<br />
==Prozedur==<br />
'''Syntax:''' <tt>void Name (Parameterliste)</tt><br />
<br />
Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp <tt>void</tt>, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede: <br />
<br />
Als Rückgabe-Datentyp wird <tt>void</tt> angegeben. <br />
Einer Variablen kann daher nicht der Rückgabewert einer <tt>void</tt>-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int param1)<br />
{<br />
printf ("Der Wert der Variablen ist: %d\n", param1);<br />
}<br />
<br />
int main(void)<br />
{<br />
int zahl1 = 4;<br />
<br />
ausgeben (23);<br />
ausgeben (zahl1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Durch den Befehl "<tt>ausgeben(23)</tt>" wird die Prozedur "<tt>ausgeben</tt>" mit dem Parameter <tt>23</tt> aufgerufen. <tt>param1</tt> hat also den Wert <tt>23</tt>. Die einzige Anweisung innerhalb der Prozedur ist <tt>printf</tt>, was nun ausgeführt wird. <br />
Der zweite Aufruf von <tt>ausgeben</tt> erfolgt mit dem Parameter <tt>zahl1</tt>, also wird <tt>param1</tt> der Wert 4 zugewiesen. Dieser wird nun wieder mittels <tt>printf</tt> ausgeben. <br />
<br />
Unterprogramme ohne Parameter<br />
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur <tt>void</tt> stehen. Das <tt>void</tt> bedeutet "die Funktion erhält keine Parameter". "<tt>void main (void)</tt>" bedeutet also: "Erstelle ein Unterprogramm Namens <tt>main</tt>, das keinen Rückgabewert und keine Parameter hat".<br />
<br />
{{FarbigerRahmen |<br />
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:<br />
foo();<br />
}}<br />
<br />
==Prototypen==<br />
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?<br />
Um dies zu erreichen, gibt es zwei Möglichkeiten: <br />
<br />
Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! <br />
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. <br />
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt&nbsp;<tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). <br />
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int zahl); /* Der Prototyp */<br />
<br />
int main (void)<br />
{<br />
ausgeben (12);<br />
<br />
return 0;<br />
}<br />
<br />
void ausgeben (int zahl) /* Die eigentliche Prozedur */<br />
{<br />
printf ("Ausgabe: %d\n", zahl);<br />
}<br />
</pre><br />
<br />
==Parameterübergabe==<br />
<br />
Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.<br />
Das hat folgende Auswirkungen:<br />
<br />
# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!<br />
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger | Zeiger]] übergeben werden.<br />
# Werden [[#Strukturen | Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.<br />
<br />
<br />
Beispiele:<br />
<pre><br />
void erhoehe (int x)<br />
{<br />
x = x + 1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int a = 0;<br />
erhoehe(a);<br />
/* a ist immer noch 0 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.<br />
<br />
<pre><br />
void erhoehe (int *x)<br />
{<br />
/* erhöhe den Wert an der Adresse x um eins */<br />
*x = *x + 1;<br />
}<br />
<br />
int main(void)<br />
{<br />
int a = 0;<br />
erhoehe (&a);<br />
/* a ist jetzt 1 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&amp;</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die<br />
Adresse des Originals <tt>a</tt> und kann direkt mit dem Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.<br />
<br />
<br />
'''Besonderheit bei Feldern'''<br />
<br />
Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines<br />
Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.<br />
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf<br />
den Originaldaten arbeiten und diese verändern.<br />
<br />
Beispiel:<br />
<pre><br />
void erhoehe (int x[])<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
<br />
Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:<br />
<br />
<pre><br />
/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */<br />
void erhoehe (int *x)<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
}<br />
</pre><br />
<br />
{{FarbigerRahmen |<br />
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.<br />
}}<br />
<br />
=Standard-Funktionen=<br />
<br />
==strcpy==<br />
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren! <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri1[21], eingabe[21];<br />
<br />
strcpy (stri1, "hallo");<br />
<br />
printf ("Der 1. String: %s\n", stri1);<br />
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");<br />
scanf ("%s", eingabe);<br />
strcpy (stri1, eingabe);<br />
printf ("\n%s = %s", stri1, eingabe);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Hinweis:''' <br />
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&amp;</tt> bei <tt>scanf</tt> angeben!<br />
<br />
'''Erklärung:''' <br />
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen. <br />
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. <br />
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings. <br />
Sie werden gebeten, eine String einzugeben. <br />
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert. <br />
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.<br />
<br />
==strlen==<br />
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern. <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri[21];<br />
<br />
strcpy (stri, "hallo");<br />
printf ("Der String ist %d Zeichen lang", strlen (stri));<br />
}<br />
</pre><br />
<br />
Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc. <br />
<br />
<br />
<br />
===Zeiger als Parameter===<br />
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.<br />
Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable"). <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void erhoehe (int *zeiger)<br />
{<br />
*zeiger = *zeiger+1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl;<br />
<br />
printf ("Zahl eingeben: ");<br />
scanf ("%d", &zahl);<br />
erhoehe (&zahl);<br />
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
==Parameter von <tt>main</tt>==<br />
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen. <br />
<pre><br />
int main (int argc, char *argv[], char* environ[])<br />
</pre><br />
<br />
Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge&nbsp;0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.<br />
<pre><br />
#include <stdio.h><br />
#include <stdlib.h><br />
<br />
int main (int argc, char *argv[], char * environ[])<br />
{<br />
int i;<br />
<br />
printf ("Es wurden %d Parameter angegeben", argc);<br />
<br />
for (i=0; i < argc; i++) <br />
printf ("Parameter %d: %s\n", i, argv[i]);<br />
<br />
for (i = 0; environ[i] != NULL; ++i) <br />
printf ("environ[%d] = %s\n", i, environ[i]);<br />
}<br />
</pre><br />
<br />
;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement &ndash; wie in C üblich &ndash; das Element <tt><tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen! <br />
<br />
=Liste der Schlüsselworte=<br />
<br />
* [[#Speicherklassen|auto]]<br />
* break<br />
* [[#Elementare Datentypen|double]]<br />
* [[#Elementare Datentypen|char]]<br />
* case<br />
* [[#Konstanten|const]]<br />
* continue<br />
* default<br />
* do<br />
* else<br />
* enum<br />
* [[#Speicherklassen|extern]]<br />
* [[#Elementare Datentypen|float]]<br />
* for<br />
* goto<br />
* if<br />
* [[##Elementare Datentypen|int]]<br />
* [[#Elementare Datentypen|long]]<br />
* return<br />
* [[#Speicherklassen|register]]<br />
* [[#Elementare Datentypen|short]]<br />
* signed<br />
* sizeof<br />
* [[#Speicherklassen|static]]<br />
* [[#Strukturen|struct]]<br />
* switch<br />
* typedef<br />
* [[#Unions|union]]<br />
* unsigned<br />
* [[#Elementare Datentypen|void]]<br />
* volatile<br />
* while<br />
<br />
Baustelle<br />
<br />
=Liste der Operatoren=<br />
<br />
Baustelle<br />
<br />
<font color="blue"><></font><br />
<br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung || Nebeneffekte<br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> == <font color="blue"><Ausdruck></font></tt> || ist gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> != <font color="blue"><Ausdruck></font></tt> || ist nicht gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt; <font color="blue"><Ausdruck></font></tt> || ist kleiner <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt;= <font color="blue"><Ausdruck></font></tt> || ist kleiner oder gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt; <font color="blue"><Ausdruck></font></tt> || ist größer <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt;= <font color="blue"><Ausdruck></font></tt> || ist größer oder gleich <br />
|-<br />
| <tt>&amp; <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> = <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> += <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> -= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> *= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> /= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ^= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> &= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> |= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>++ <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ++</tt> || <br />
|-<br />
| <tt>-- <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> --</tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> && <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> <nowiki>||</nowiki> <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>~ <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>! <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Type></font>) <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> + <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> - <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> * <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> / <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> % <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> %= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Bedingung></font>) ? <font color="blue"><Ausdruck></font> : <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Struct></font>.<font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Zeiger-auf-Struct></font>-><font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|}<br />
<br />
<br />
'''Autoren'''<br />
* Plasma<br />
* Bernd<br />
* [[Benutzer:SprinterSB|SprinterSB]]<br />
<br />
'''Quellen:'''<br />
* Kernighan und Ritchie - Buch<br />
* Christian Wirth , C Tutorial<br />
* Prof. Dr. J. Dankert Ausführungen<br />
<br />
=Siehe auch=<br />
* [[avr-gcc]]<br />
* [[Compiler]]<br />
* [[WinAVR]]<br />
* [[Fallstricke bei der C-Programmierung]]<br />
<br />
=Weblinks=<br />
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]<br />
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]<br />
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]<br />
<br />
[[Kategorie:Quellcode C|!]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=C-Tutorial&diff=8130C-Tutorial2006-07-05T12:02:48Z<p>Roberto: /* Strukturen */</p>
<hr />
<div>Ein kurzer Einblick in die Programmiersprache C<br />
=Allgemeines=<br />
C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.<br />
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.<br />
<br />
C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu lediglich einen anderen Compiler, und Inline-Assembler Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden. <br />
<br />
==Geschichte==<br />
;1971: C wird entwickelt<br />
;1978: Kernighan und Ritchie definieren die Sprache.<br />
;1983: ANSI und ISO standardisieren C.<br />
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.<br />
<br />
=Aufbau eines C-Programmes=<br />
<!-- <br />
<br />
C-Programme haben keinen fixen Aufbau wie z.B. Pascal. Es gibt zwar gewisse Regeln, aber sonst sind dem Programmierer alle Freiheiten überlassen. Der folgende "Beispiel-Aufbau" ist daher nicht zwingend und kann durchaus verändert werden.<br />
<br />
Natürlich haben C-Programme einen fixen Aufbau! Ebenso wie Pascal-Programme auch unterliegen sie einer strikten Grammatik! <br />
Auskommentiert --[[Benutzer:SprinterSB|SprinterSB]] 10:23, 17. Feb 2006 (CET)<br />
--><br />
Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau. <br />
<pre><br />
#include <stdio.h><br />
<br />
int Zahl1;<br />
char Zeichen1;<br />
<br />
int main (void)<br />
{<br />
int zahl2;<br />
<br />
/* Anweisungen */<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Beschreibung (die Erklärungen folgen): <br />
<br />
;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.<br />
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.<br />
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert. <br />
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.<br />
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.<br />
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert. <br />
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.<br />
;return 0;: Gibt den Wert&nbsp;0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.<br />
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.<br />
<br />
=Das Hauptprogramm main=<br />
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm. <br />
<br />
Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer &ndash; üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt. <br />
<br />
Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!<br />
<pre><br />
/* <br />
* void Definition von main ist nur beim Controller üblich<br />
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main<br />
* kein Fehler/Warnung erzeugt wird. <br />
*/<br />
void main (void)<br />
{<br />
...<br />
}<br />
</pre><br />
<br />
=Blöcke=<br />
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung.<br />
Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende": <br />
<br />
<pre><br />
int main (void)<br />
{ /* der Block "main" beginnt */<br />
int zahl;<br />
<br />
{ /* ein Block beginnt */<br />
/* hier können Deklarationen und Anweisungen stehen */<br />
} /* der Block endet */<br />
<br />
return 0;<br />
} /* "main" endet */<br />
</pre><br />
<br />
'''Bemerkung:''' <br />
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!<br />
<br />
=Datentypen=<br />
==Elementare Datentypen==<br />
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.<br />
<br />
;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!<br />
<br />
===int, char, short, long (ganze Zahlen)===<br />
In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen. <br />
<br />
Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann reicht der Wertebereich von <tt>-2<sup>''b''-1</sup></tt> bis zu <tt>2<sup>''b''-1</sup>-1</tt>.<br />
<br />
Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2<sup>''b''</sup>-1</tt>, wenn der Typ ''b'' Bits breit ist.<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs<br />
|- <br />
| 8 || <tt>char</tt> <br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -128<br />0<br />
| align="right" | 127<br />255<br />
|- <br />
| 16 || <tt>short</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -32.768<br />0<br />
| align="right" | 32.767<br />65.535<br />
|- <br />
| 32 || <tt>long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -2.147.483.648<br />0<br />
| align="right" | 2.147.483.647<br />4.294.967.295<br />
|- <br />
| 64 || <tt>long long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -9.223.372.036.854.775.808<br />0<br />
| align="right" | 9.223.372.036.854.775.807<br />18.446.744.073.709.551.615<br />
|-<br />
|8, 16, 32, 64<br/><br />
| <tt>int</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
|plattform-/compilerabhängig<br />
|plattform-/compilerabhängig<br />
|}<br />
</center><br />
<br />
==== Boolean (Logische Variablen)====<br />
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.<br />
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.<br />
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert&nbsp;1 haben muß. Sie muß lediglich ungleich&nbsp;0 sein!<br />
<br />
====char (Zeichen)====<br />
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen. <br />
<br />
Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!<br />
<br />
===float, double (Gleitkommazahlen)===<br />
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. <br />
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.<br />
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.<br />
<br />
===void===<br />
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.<br />
<br />
==Zeiger==<br />
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''. <br />
<br />
Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein&nbsp;<tt>&</tt> voranstellt. Die Umkehrung davon &ndash; also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist &ndash; erledigt ein vorgestellter&nbsp;<tt>*</tt>. Der Operator &nbsp;<tt>*</tt> gibt also den ''Inhalt'' der Adresse.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int * zeiger;<br />
int zahl;<br />
<br />
zeiger = &zahl;<br />
*zeiger = 12;<br />
<br />
printf ("%d = %d", zahl, *zeiger);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der&nbsp;<tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:<br />
int * zeiger, zahl;<br />
<br />
Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator&nbsp;<tt>&</tt> von <tt>zahl</tt>:<br />
zeiger = &zahl; <br />
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>). <br />
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.<br />
<br />
==Zusammengesetzte Datentypen==<br />
===Arrays===<br />
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays &ndash; teilweise auch als ''Felder'' bezeichnet &ndash; zu verwenden.<br />
<br />
In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> arbeiten!<br />
<br />
'''Syntax:''' Datentyp Variablenname[Anzahl]<br />
<br />
Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für 3 Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes. <br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int i;<br />
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */<br />
<br />
for (i=0; i<10; i++)<br />
{<br />
printf ("Bitte Zahl %d eingeben: ", i);<br />
scanf ("%d", & zahlen[i]);<br />
printf ("\n");<br />
}<br />
printf ("Super!\n");<br />
<br />
for (i=0; i<10; i++) <br />
printf ("Zahl %d ist: %d\n", i, zahlen[i]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen:''' <br />
Zuerst wird ein 10 int-Variablen großes Array angelegt. <br />
In dieses wird nun der Reihe nach 10 Zahlen eingelesen. <br />
Anschließend werden alle 10 Zahlen ausgegeben. <br />
<br />
{{FarbigerRahmen|<br />
'''Merke:'''<br />
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!<br />
}}<br />
<br />
===Strings (Zeichenketten)===<br />
Ein String ist nichts anderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.<br />
<br />
Die Definition eines Strings erfolgt also genauso wie bei Arrays:<br />
char string[21];<br />
<br />
Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert". <br />
<br />
Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.<br />
<br />
===Mehrdimensionale Arrays===<br />
Manchmal benötigt man mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.<br />
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:<br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int x,y;<br />
int feld[3][5];<br />
<br />
for (x=0; x<3; x++) <br />
{<br />
for (y=0; y<5; y++)<br />
{<br />
printf ("Feldwert x: %d, y: %d ", x, y);<br />
scanf ("%d", & feld[x][y]);<br />
printf ("\n");<br />
}<br />
}<br />
<br />
for(x=0; x<3; x++) <br />
for (y=0; y<5; y++) <br />
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Erklärung:''' <br />
<br />
Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt. <br />
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>. <br />
Zum Schluß werden alle Werte noch einmal ausgegeben.<br />
<br />
===Strukturen===<br />
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden: <br />
<br />
<pre><br />
struct Person <br />
{<br />
int id;<br />
char vname[20], nname[20];<br />
char telnr[15];<br />
int alter;<br />
};<br />
</pre><br />
<br />
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein. <br />
Dann werden in dieser Struktur vier Komponenten angelegt: drei Strings und zwei <tt>int</tt>. <br />
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach <br />
struct Person Variablenname;<br />
an. <br />
<br />
Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:<br />
<pre><br />
struct Person hubert, klaus;<br />
<br />
hubert.alter = 32;<br />
klaus.alter = hubert.alter + 1;<br />
</pre><br />
<br />
===Unions===<br />
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.<br />
<pre><br />
union Daten <br />
{<br />
int id;<br />
<br />
struct u_double<br />
{<br />
int id;<br />
double wert;<br />
};<br />
<br />
struct Person u_person;<br />
<br />
struct u_pointer<br />
{<br />
int id;<br />
union Daten * p1;<br />
union Daten * p2;<br />
};<br />
};<br />
<br />
union Daten data;<br />
</pre><br />
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_double</tt>, <tt>u_person</tt> und <tt>u_pointer</tt>. Die Große der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden.<br />
<br />
Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:<br />
<pre><br />
typedef union<br />
{<br />
unsigned long as_long;<br />
unsignen chat as_byte[4];<br />
} data32_t;<br />
</pre><br />
Dies überlagert einen <tt>unsigned long</tt> &ndash; also eine 32-Bit-Zahl &ndash; mit vier Bytes.<br />
<pre><br />
data32_t wert;<br />
<br />
wert.as_long = 0x12345678;<br />
wert.as_byte[0] = 0xab;<br />
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */<br />
</pre><br />
<br />
=Variablen=<br />
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.<br />
<br />
==Variablennamen==<br />
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.<br />
<br />
Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.<br />
==Anlegen von Variablen==<br />
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung! <br />
<pre><br />
int Zahl1, Zahl2;<br />
char Zeichen;<br />
<br />
int main (void)<br />
{<br />
float gleitZahl;<br />
/* Anweisungen */<br />
<br />
return 0;<br />
}<br />
</pre><br />
;Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].<br />
<br />
==Zuweisungen==<br />
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]]. <br />
<pre><br />
int main (void)<br />
{<br />
int zahl1, zahl2 = 12;<br />
char zeichen1 = 'A';<br />
<br />
zahl1 = 52;<br />
zeichen1 = zeichen1 + 1; <br />
<br />
return 0;<br />
}<br />
</pre><br />
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>). <br />
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen. <br />
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.<br />
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.<br />
<br />
==Zuweisungen bei float==<br />
Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt: <br />
floatVariable = 3.14;<br />
Zusätzlich kann eine Zehnerpotenz angegeben werden:<br />
floatVariable2 = -1.234E-6;<br />
Dadurch wird der erst Wert mit 10<sup><tt>-</tt>6</sup> multipliziert, der Wert der Variablen ist also <br />
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.<br />
<br />
==Zuweisungen bei logischen Variablen==<br />
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr". <br />
intVariable = !0; /* entspricht "wahr" */<br />
intVariable = 0; /* entspricht "unwahr" */<br />
<br />
==Vergleich von Variablen==<br />
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln: <br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|}<br />
</center><br />
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl. <br />
intVariable = zahl1 <= zahl2;<br />
das komplette Beispiel zeigt es deutlicher:<br />
<pre><br />
int i;<br />
int z1, z2;<br />
<br />
z1 = 5;<br />
z2 = 100;<br />
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */<br />
<br />
printf ("Ergebnis: %d\n", i);<br />
</pre><br />
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").<br />
<br />
==Konstanten==<br />
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:<br />
const ''datentyp'' name = value; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. <br />
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.<br />
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit<br />
* ((float*) &PI) = 2;<br />
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.<br />
<br />
Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist<br />
void foo (const char * str, ...);<br />
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.<br />
<br />
Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:<br />
void foo (char * const str, ...);<br />
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>. Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim&nbsp;<tt>*</tt> auf: Steht das <tt>const</tt> links vom&nbsp;<tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides &ndash; also den Zeiger und sein Ziel &ndash; als konstant zu markieren.<br />
<br />
==Gültigkeitsbereich==<br />
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln: <br />
<br />
;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.<br />
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.<br />
<br />
==Speicherklassen==<br />
Jede Variable in C gehört zu einer bestimmten Speicherklasse<br />
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.<br />
;<tt>extern</tt>: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].<br />
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.<br />
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable &ndash; falls möglich &ndash; als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!<br />
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.<br />
<br />
=Ausdrücke=<br />
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.<br />
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.<br />
<br />
Einfache Beispiele für Ausdrücke sind also z.B.:<br />
1<br />
a<br />
'a'<br />
1 + a<br />
a == 1<br />
<br />
Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.<br />
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,<br />
und wei man damit neue Ausdrücke aufbauen kann.<br />
<br />
==Lvalues==<br />
<br />
Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.<br />
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.<br />
<br />
Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:<br />
a = 1;<br />
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie<br />
a+1 = 2;<br />
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":<br />
"ungültiger Wert in Zuweisung"<br />
<br />
Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante&nbsp;4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung&nbsp;<tt>*</tt> wird an die Adresse&nbsp;4 im Speicher eine&nbsp;3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.<br />
* ((unsigned int *) 4) = 3;<br />
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue<br />
<br />
==Logische (boolsche) Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a &amp;&amp; b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr<br />
|-<br />
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr<br />
|-<br />
|<tt>a == b</tt> || gleich<br />
|-<br />
|<tt>a != b</tt> || ungleich<br />
|-<br />
|<tt>a <= b</tt> || kleiner oder gleich<br />
|-<br />
|<tt>a < b</tt> || kleiner als<br />
|-<br />
|<tt>a >= b</tt> || glösser oder gleich<br />
|-<br />
|<tt>a > b</tt> || grösser als<br />
|-<br />
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa<br />
|}<br />
</center><br />
<br />
Eine interessante Eigenheit der Operatoren <tt>&amp;&amp;</tt> und <tt>||</tt> ist, dass<br />
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden<br />
dabei immer von links nach rechts ausgewertet.<br />
<br />
Beispiel:<br />
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */<br />
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */<br />
<br />
<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,<br />
die eine aufwändige Operation durchführt.<br />
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder<br />
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.<br />
<br />
Wo ist also der Unterschied?<br><br />
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,<br />
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.<br />
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte<br />
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.<br />
<br />
==Arithmetische Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a + b</tt> || Summe (Addition)<br />
|-<br />
|<tt>a - b</tt> || Differenz (Subtraktion)<br />
|-<br />
|<tt>a * b</tt> || Produkt (Multiplikation)<br />
|-<br />
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)<br />
|-<br />
|<tt>a % b</tt> || Rest bei Division (Modulo)<br />
|-<br />
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)<br />
|}<br />
</center><br />
==Bit-Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a & b</tt> || bitweise und (and)<br />
|-<br />
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)<br />
|-<br />
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)<br />
|-<br />
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)<br />
|}<br />
</center><br />
==Index-Operator bei Arrays==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a<br />
|}<br />
</center><br />
<br />
Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:<br />
<br />
# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein<br />
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)<br />
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!<br />
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung<br />
<br />
==Komponenten-Auswahl bei Structs und Unions==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a<br />
|}<br />
</center><br />
<br />
==Adress-Operator und Dereferenzierung==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>&amp;a</tt> || Speicheradresse der Variablen <tt>a</tt><br />
|-<br />
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht<br />
|-<br />
||<tt>a-&gt;b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht<br />
|}<br />
</center><br />
<br />
Der Adressoperator & kann auf Variablen angewendet werden und<br />
gibt die Startadresse der Variablen im Speicher zurück.<br />
<br />
Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält<br />
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der<br />
an dieser Adresse steht, wird der Operator * vorangestellt.<br />
<br />
Beispiel:<br />
<pre><br />
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */<br />
<br />
/* z ist ein Zeiger auf eine Integervariable und enthält somit<br />
die Speicheradresse einer Integervariablen<br />
*/<br />
int *z; <br />
<br />
/* Verwendung des Adressoperators... */<br />
z = &x; /* weise z die Speicheradresse von x zu */<br />
<br />
/* Verwendung der Dereferenzierung */<br />
/* erhöhe den Wert, der bei Adresse z steht um eins */<br />
*z = *z + 1;<br />
<br />
/* da z auf x zeigt, hat auch x jetzt den Wert 6 */<br />
</pre><br />
<br />
Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff<br />
auf ein Element eine abkürzende Schreibweise möglich:<br />
<br />
Statt <br />
(*strukturZeiger).element<br />
kann geschrieben werden<br />
strukturZeiger->element<br />
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch<br />
auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu<br />
einer Änderung '''irgendeiner''' Speicherstelle:<br />
<br />
<pre><br />
int *z; /* z ist ein Zeiger auf einen Integer */<br />
<br />
/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.<br />
z enthält irgendeine(!) Adresse<br />
*/<br />
<br />
/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */<br />
*z = *z + 1;<br />
</pre><br />
<br />
Viele C-Compiler (z.B. gcc) erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!<br />
}}<br />
<br />
==Cast-Operator==<br />
<br />
Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.<br />
<br />
Um zum Beispiel aus einem Float ein Integer zu machen:<br />
var = (int) 5.60;<br />
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.<br />
<br />
Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:<br />
int * addr;<br />
addr = (int*) 0x1234;<br />
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder<br />
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in<br />
eine Zahl oder umgekehrt zu wandeln:<br />
<br />
<pre><br />
#include <stdio.h><br />
int main(int argc, char ** argv)<br />
{<br />
char text[] = "5.6";<br />
int zahl = (int)text;<br />
<br />
printf("%d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator<br />
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.<br />
}}<br />
<br />
==Komma Operator==<br />
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.<br />
Die Auswertung erfolgt von links nach rechts.<br />
<br />
Solche Konstrukte sieht man manchmal in Abfragen wie<br />
FILE *file;<br />
if (file = fopen ("foo.exe", "r"), file != NULL)<br />
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,<br />
wenn <tt>file</tt> nicht der Nullpointer ist.<br />
<br />
==Zuweisungen und Operatoren mit Nebeneffekt==<br />
===Bedingte Zuweisung===<br />
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;<br />
<br />
<!--<br />
Kein ANSI-C<br />
--[[Benutzer:SprinterSB|SprinterSB]] 17:15, 29. Jun 2006 (CEST)<br />
==Blöcke==<br />
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.<br />
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks. <br />
Der Block muss un runden Klammern stehen:<br />
int sum;<br />
sum = ({<br />
int i, s = 0;<br />
for (i=1; i<= 100; i++)<br />
s += i;<br />
s;<br />
});<br />
<br />
Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc, <br />
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer<br />
Instruktion nicht machbar wäre:<br />
<pre><br />
#define PSTR(s) \<br />
({ \ <br />
static char __c[] PROGMEM = (s); \<br />
__c; \<br />
})<br />
</pre><br />
--><br />
<br />
==Reihenfolge der Auswertung==<br />
<br />
=Kontrollanweisungen=<br />
<br />
==Boolsche Logik==<br />
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird). <br />
<br />
b1= b2 && b3;<br />
<br />
<br />
Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).<br />
<br />
<br />
b1= b2 || b3;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.<br />
<br />
<br />
b1= !b2;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".<br />
<br />
==<tt>if</tt>-Anweisung==<br />
Syntax: IF (Bedingung) Anweisung;<br />
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:<br />
<br />
[[bild:ifthenelse.png]]<br />
<br />
Und in C schreibt man:<br />
<pre><br />
if (Bedingung) /* WENN */<br />
{ /* DANN */<br />
Anweisung1;<br />
Anweisung2;<br />
...<br />
}<br />
else<br />
{ /* SONST */<br />
Anweisung3;<br />
Anweisung4;<br />
...<br />
}<br />
</pre><br />
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt. <br />
<br />
Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki><br />
<br />
<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki><br />
<br />
<br />
Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.<br />
}}<br />
<br />
==<tt>switch</tt>-Anweisung==<br />
Syntax: <br />
<pre><br />
switch(ausdruck) {<br />
case wert1:<br />
Anweisungen1...<br />
case wert2:<br />
Anweisungen2...<br />
case wert3:<br />
Anweisungen3...<br />
...<br />
default:<br />
Anweisungen4...<br />
}<br />
</pre><br />
<br />
Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter<br />
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der<br />
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt><br />
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.<br />
<br />
<b>Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines<br />
<tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!</b><br />
<br />
Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.<br />
Der <tt>default</tt>-Abschnitt ist optional, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,<br />
wenn er verwendet wird.<br />
<br />
<br />
==Schleifen==<br />
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.<br> <br />
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird. <br />
<br />
===<tt>while</tt>-Schleife===<br />
'''Syntax:''' while (Bedingung) { Anweisung; }<br />
<br />
Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block! <br />
<br />
<pre><br />
Zahl1=0;<br />
while (Zahl1<3)<br />
{<br />
Zahl1=Zahl1+1;<br />
Zahl2=Zahl2*2;<br />
}<br />
</pre><br />
<br />
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.<br />
===<tt>do</tt>-<tt>while</tt>-Schleife===<br />
'''Syntax:''' do { Anweisung; }while (Bedingung);<br />
<br />
Die DO WHILE-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird <br />
<br />
<pre><br />
int i=2;<br />
do <br />
{<br />
i = i*i; /* i quadrieren */<br />
printf ("i = %d\n", i);<br />
}<br />
while (i < 20);<br />
</pre><br />
<br />
Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.<br />
<br />
===<tt>for</tt>-Schleife===<br />
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }<br />
<br />
Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.<br />
<br />
Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.<br />
<br />
Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet. <br />
<br />
<pre><br />
int lauf;<br />
int summe = 0;<br />
<br />
for (lauf = 1; lauf <= 10; lauf = lauf+2 ) <br />
{<br />
summe = summe + lauf;<br />
}<br />
</pre><br />
Das Äquivalent als <tt>while</tt>-Schleife:<br />
<pre><br />
int lauf = 1; /* Anfangswerte */<br />
int summe = 0;<br />
<br />
while (lauf <= 10) /* Bedingung */<br />
{<br />
summe = summe + lauf;<br />
lauf += 2; /* Inkrement */<br />
}<br />
</pre><br />
<br />
<br />
In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.<br />
<br />
'''Erklärung:''' <br />
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. <br />
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. <br />
<tt>lauf = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um&nbsp;2 erhöht wird.<br />
<br />
=Ein- und Ausgabe=<br />
<br />
==Bildschirm-Ausgabe==<br />
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.<br />
<br />
Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, </tt>char</tt>, <tt>double</tt>...) sein! <br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int zahl1 = 12;<br />
char zeichen1 = 'A';<br />
<br />
printf ("Das ist Text, und er wird als solcher ausgegeben. \n");<br />
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile. <br />
<br />
Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus. <br />
<br />
In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert. <br />
<br />
Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen! <br />
<br />
==Tastatur-Eingabe==<br />
<br />
Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.<br />
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>: <br />
<br />
<pre><br />
int zahl1;<br />
char zeichen1;<br />
<br />
printf ("Bitte geben Sie eine Zahl ein: ");<br />
scanf ("%d", &zahl1);<br />
printf ("Geben Sie einen Zeichen ein: ");<br />
scanf ("%c", &zeichen1);<br />
</pre><br />
<br />
Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.<br />
<br />
Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!<br />
<br />
Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference"). <br />
<br />
<br />
=Allgemeines zu Unterprogrammen=<br />
Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen.<br />
Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen: <br />
<br />
==Funktionen==<br />
'''Syntax:''' Rückgabe-Typ Name(Parameterliste);<br />
<br />
Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln: <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int hoch2 (int param1)<br />
{<br />
int zahl;<br />
zahl = param1 * param1;<br />
return zahl;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl1, ergebnis;<br />
<br />
printf ("Bitte Zahl eingeben: ");<br />
scanf ("%d",&zahl1);<br />
<br />
ergebnis = hoch2 (zahl1);<br />
<br />
printf ("%d hoch 2 = %d\n",zahl1, ergebnis);<br />
printf ("5 hoch 2 = %d\n", hoch2(5));<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. <br />
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. <br />
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.<br />
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. <br />
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert. <br />
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an<br />
variable = Funktion (Parameter);<br />
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile). <br />
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.<br />
<br />
==Prozedur==<br />
'''Syntax:''' <tt>void Name (Parameterliste)</tt><br />
<br />
Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp <tt>void</tt>, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede: <br />
<br />
Als Rückgabe-Datentyp wird <tt>void</tt> angegeben. <br />
Einer Variablen kann daher nicht der Rückgabewert einer <tt>void</tt>-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int param1)<br />
{<br />
printf ("Der Wert der Variablen ist: %d\n", param1);<br />
}<br />
<br />
int main(void)<br />
{<br />
int zahl1 = 4;<br />
<br />
ausgeben (23);<br />
ausgeben (zahl1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Durch den Befehl "<tt>ausgeben(23)</tt>" wird die Prozedur "<tt>ausgeben</tt>" mit dem Parameter <tt>23</tt> aufgerufen. <tt>param1</tt> hat also den Wert <tt>23</tt>. Die einzige Anweisung innerhalb der Prozedur ist <tt>printf</tt>, was nun ausgeführt wird. <br />
Der zweite Aufruf von <tt>ausgeben</tt> erfolgt mit dem Parameter <tt>zahl1</tt>, also wird <tt>param1</tt> der Wert 4 zugewiesen. Dieser wird nun wieder mittels <tt>printf</tt> ausgeben. <br />
<br />
Unterprogramme ohne Parameter<br />
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur <tt>void</tt> stehen. Das <tt>void</tt> bedeutet "die Funktion erhält keine Parameter". "<tt>void main (void)</tt>" bedeutet also: "Erstelle ein Unterprogramm Namens <tt>main</tt>, das keinen Rückgabewert und keine Parameter hat".<br />
<br />
{{FarbigerRahmen |<br />
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:<br />
foo();<br />
}}<br />
<br />
==Prototypen==<br />
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?<br />
Um dies zu erreichen, gibt es zwei Möglichkeiten: <br />
<br />
Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! <br />
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. <br />
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt&nbsp;<tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). <br />
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int zahl); /* Der Prototyp */<br />
<br />
int main (void)<br />
{<br />
ausgeben (12);<br />
<br />
return 0;<br />
}<br />
<br />
void ausgeben (int zahl) /* Die eigentliche Prozedur */<br />
{<br />
printf ("Ausgabe: %d\n", zahl);<br />
}<br />
</pre><br />
<br />
==Parameterübergabe==<br />
<br />
Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.<br />
Das hat folgende Auswirkungen:<br />
<br />
# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!<br />
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger | Zeiger]] übergeben werden.<br />
# Werden [[#Strukturen | Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.<br />
<br />
<br />
Beispiele:<br />
<pre><br />
void erhoehe (int x)<br />
{<br />
x = x + 1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int a = 0;<br />
erhoehe(a);<br />
/* a ist immer noch 0 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.<br />
<br />
<pre><br />
void erhoehe (int *x)<br />
{<br />
/* erhöhe den Wert an der Adresse x um eins */<br />
*x = *x + 1;<br />
}<br />
<br />
int main(void)<br />
{<br />
int a = 0;<br />
erhoehe (&a);<br />
/* a ist jetzt 1 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&amp;</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die<br />
Adresse des Originals <tt>a</tt> und kann direkt mit dem Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.<br />
<br />
<br />
'''Besonderheit bei Feldern'''<br />
<br />
Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines<br />
Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.<br />
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf<br />
den Originaldaten arbeiten und diese verändern.<br />
<br />
Beispiel:<br />
<pre><br />
void erhoehe (int x[])<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
<br />
Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:<br />
<br />
<pre><br />
/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */<br />
void erhoehe (int *x)<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
}<br />
</pre><br />
<br />
{{FarbigerRahmen |<br />
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.<br />
}}<br />
<br />
=Standard-Funktionen=<br />
<br />
==strcpy==<br />
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren! <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri1[21], eingabe[21];<br />
<br />
strcpy (stri1, "hallo");<br />
<br />
printf ("Der 1. String: %s\n", stri1);<br />
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");<br />
scanf ("%s", eingabe);<br />
strcpy (stri1, eingabe);<br />
printf ("\n%s = %s", stri1, eingabe);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Hinweis:''' <br />
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&amp;</tt> bei <tt>scanf</tt> angeben!<br />
<br />
'''Erklärung:''' <br />
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen. <br />
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. <br />
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings. <br />
Sie werden gebeten, eine String einzugeben. <br />
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert. <br />
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.<br />
<br />
==strlen==<br />
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern. <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri[21];<br />
<br />
strcpy (stri, "hallo");<br />
printf ("Der String ist %d Zeichen lang", strlen (stri));<br />
}<br />
</pre><br />
<br />
Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc. <br />
<br />
<br />
<br />
===Zeiger als Parameter===<br />
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.<br />
Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable"). <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void erhoehe (int *zeiger)<br />
{<br />
*zeiger = *zeiger+1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl;<br />
<br />
printf ("Zahl eingeben: ");<br />
scanf ("%d", &zahl);<br />
erhoehe (&zahl);<br />
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
==Parameter von <tt>main</tt>==<br />
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen. <br />
<pre><br />
int main (int argc, char *argv[], char* environ[])<br />
</pre><br />
<br />
Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge&nbsp;0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.<br />
<pre><br />
#include <stdio.h><br />
#include <stdlib.h><br />
<br />
int main (int argc, char *argv[], char * environ[])<br />
{<br />
int i;<br />
<br />
printf ("Es wurden %d Parameter angegeben", argc);<br />
<br />
for (i=0; i < argc; i++) <br />
printf ("Parameter %d: %s\n", i, argv[i]);<br />
<br />
for (i = 0; environ[i] != NULL; ++i) <br />
printf ("environ[%d] = %s\n", i, environ[i]);<br />
}<br />
</pre><br />
<br />
;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement &ndash; wie in C üblich &ndash; das Element <tt><tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen! <br />
<br />
=Liste der Schlüsselworte=<br />
<br />
* [[#Speicherklassen|auto]]<br />
* break<br />
* [[#Elementare Datentypen|double]]<br />
* [[#Elementare Datentypen|char]]<br />
* case<br />
* [[#Konstanten|const]]<br />
* continue<br />
* default<br />
* do<br />
* else<br />
* enum<br />
* [[#Speicherklassen|extern]]<br />
* [[#Elementare Datentypen|float]]<br />
* for<br />
* goto<br />
* if<br />
* [[##Elementare Datentypen|int]]<br />
* [[#Elementare Datentypen|long]]<br />
* return<br />
* [[#Speicherklassen|register]]<br />
* [[#Elementare Datentypen|short]]<br />
* signed<br />
* sizeof<br />
* [[#Speicherklassen|static]]<br />
* [[#Strukturen|struct]]<br />
* switch<br />
* typedef<br />
* [[#Unions|union]]<br />
* unsigned<br />
* [[#Elementare Datentypen|void]]<br />
* volatile<br />
* while<br />
<br />
Baustelle<br />
<br />
=Liste der Operatoren=<br />
<br />
Baustelle<br />
<br />
<font color="blue"><></font><br />
<br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung || Nebeneffekte<br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> == <font color="blue"><Ausdruck></font></tt> || ist gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> != <font color="blue"><Ausdruck></font></tt> || ist nicht gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt; <font color="blue"><Ausdruck></font></tt> || ist kleiner <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt;= <font color="blue"><Ausdruck></font></tt> || ist kleiner oder gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt; <font color="blue"><Ausdruck></font></tt> || ist größer <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt;= <font color="blue"><Ausdruck></font></tt> || ist größer oder gleich <br />
|-<br />
| <tt>&amp; <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> = <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> += <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> -= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> *= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> /= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ^= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> &= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> |= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>++ <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ++</tt> || <br />
|-<br />
| <tt>-- <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> --</tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> && <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> <nowiki>||</nowiki> <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>~ <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>! <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Type></font>) <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> + <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> - <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> * <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> / <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> % <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> %= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Bedingung></font>) ? <font color="blue"><Ausdruck></font> : <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Struct></font>.<font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Zeiger-auf-Struct></font>-><font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|}<br />
<br />
<br />
'''Autoren'''<br />
* Plasma<br />
* Bernd<br />
* [[Benutzer:SprinterSB|SprinterSB]]<br />
<br />
'''Quellen:'''<br />
* Kernighan und Ritchie - Buch<br />
* Christian Wirth , C Tutorial<br />
* Prof. Dr. J. Dankert Ausführungen<br />
<br />
=Siehe auch=<br />
* [[avr-gcc]]<br />
* [[Compiler]]<br />
* [[WinAVR]]<br />
* [[Fallstricke bei der C-Programmierung]]<br />
<br />
=Weblinks=<br />
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]<br />
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]<br />
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]<br />
<br />
[[Kategorie:Quellcode C|!]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=C-Tutorial&diff=8129C-Tutorial2006-07-05T11:58:42Z<p>Roberto: /* Mehrdimensionale Arrays */</p>
<hr />
<div>Ein kurzer Einblick in die Programmiersprache C<br />
=Allgemeines=<br />
C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.<br />
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.<br />
<br />
C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu lediglich einen anderen Compiler, und Inline-Assembler Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden. <br />
<br />
==Geschichte==<br />
;1971: C wird entwickelt<br />
;1978: Kernighan und Ritchie definieren die Sprache.<br />
;1983: ANSI und ISO standardisieren C.<br />
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.<br />
<br />
=Aufbau eines C-Programmes=<br />
<!-- <br />
<br />
C-Programme haben keinen fixen Aufbau wie z.B. Pascal. Es gibt zwar gewisse Regeln, aber sonst sind dem Programmierer alle Freiheiten überlassen. Der folgende "Beispiel-Aufbau" ist daher nicht zwingend und kann durchaus verändert werden.<br />
<br />
Natürlich haben C-Programme einen fixen Aufbau! Ebenso wie Pascal-Programme auch unterliegen sie einer strikten Grammatik! <br />
Auskommentiert --[[Benutzer:SprinterSB|SprinterSB]] 10:23, 17. Feb 2006 (CET)<br />
--><br />
Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau. <br />
<pre><br />
#include <stdio.h><br />
<br />
int Zahl1;<br />
char Zeichen1;<br />
<br />
int main (void)<br />
{<br />
int zahl2;<br />
<br />
/* Anweisungen */<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Beschreibung (die Erklärungen folgen): <br />
<br />
;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.<br />
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.<br />
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert. <br />
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.<br />
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.<br />
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert. <br />
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.<br />
;return 0;: Gibt den Wert&nbsp;0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.<br />
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.<br />
<br />
=Das Hauptprogramm main=<br />
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm. <br />
<br />
Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer &ndash; üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt. <br />
<br />
Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!<br />
<pre><br />
/* <br />
* void Definition von main ist nur beim Controller üblich<br />
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main<br />
* kein Fehler/Warnung erzeugt wird. <br />
*/<br />
void main (void)<br />
{<br />
...<br />
}<br />
</pre><br />
<br />
=Blöcke=<br />
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung.<br />
Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende": <br />
<br />
<pre><br />
int main (void)<br />
{ /* der Block "main" beginnt */<br />
int zahl;<br />
<br />
{ /* ein Block beginnt */<br />
/* hier können Deklarationen und Anweisungen stehen */<br />
} /* der Block endet */<br />
<br />
return 0;<br />
} /* "main" endet */<br />
</pre><br />
<br />
'''Bemerkung:''' <br />
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!<br />
<br />
=Datentypen=<br />
==Elementare Datentypen==<br />
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.<br />
<br />
;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!<br />
<br />
===int, char, short, long (ganze Zahlen)===<br />
In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen. <br />
<br />
Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann reicht der Wertebereich von <tt>-2<sup>''b''-1</sup></tt> bis zu <tt>2<sup>''b''-1</sup>-1</tt>.<br />
<br />
Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2<sup>''b''</sup>-1</tt>, wenn der Typ ''b'' Bits breit ist.<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs<br />
|- <br />
| 8 || <tt>char</tt> <br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -128<br />0<br />
| align="right" | 127<br />255<br />
|- <br />
| 16 || <tt>short</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -32.768<br />0<br />
| align="right" | 32.767<br />65.535<br />
|- <br />
| 32 || <tt>long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -2.147.483.648<br />0<br />
| align="right" | 2.147.483.647<br />4.294.967.295<br />
|- <br />
| 64 || <tt>long long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -9.223.372.036.854.775.808<br />0<br />
| align="right" | 9.223.372.036.854.775.807<br />18.446.744.073.709.551.615<br />
|-<br />
|8, 16, 32, 64<br/><br />
| <tt>int</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
|plattform-/compilerabhängig<br />
|plattform-/compilerabhängig<br />
|}<br />
</center><br />
<br />
==== Boolean (Logische Variablen)====<br />
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.<br />
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.<br />
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert&nbsp;1 haben muß. Sie muß lediglich ungleich&nbsp;0 sein!<br />
<br />
====char (Zeichen)====<br />
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen. <br />
<br />
Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!<br />
<br />
===float, double (Gleitkommazahlen)===<br />
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. <br />
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.<br />
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.<br />
<br />
===void===<br />
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.<br />
<br />
==Zeiger==<br />
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''. <br />
<br />
Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein&nbsp;<tt>&</tt> voranstellt. Die Umkehrung davon &ndash; also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist &ndash; erledigt ein vorgestellter&nbsp;<tt>*</tt>. Der Operator &nbsp;<tt>*</tt> gibt also den ''Inhalt'' der Adresse.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int * zeiger;<br />
int zahl;<br />
<br />
zeiger = &zahl;<br />
*zeiger = 12;<br />
<br />
printf ("%d = %d", zahl, *zeiger);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der&nbsp;<tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:<br />
int * zeiger, zahl;<br />
<br />
Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator&nbsp;<tt>&</tt> von <tt>zahl</tt>:<br />
zeiger = &zahl; <br />
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>). <br />
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.<br />
<br />
==Zusammengesetzte Datentypen==<br />
===Arrays===<br />
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays &ndash; teilweise auch als ''Felder'' bezeichnet &ndash; zu verwenden.<br />
<br />
In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> arbeiten!<br />
<br />
'''Syntax:''' Datentyp Variablenname[Anzahl]<br />
<br />
Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für 3 Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes. <br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int i;<br />
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */<br />
<br />
for (i=0; i<10; i++)<br />
{<br />
printf ("Bitte Zahl %d eingeben: ", i);<br />
scanf ("%d", & zahlen[i]);<br />
printf ("\n");<br />
}<br />
printf ("Super!\n");<br />
<br />
for (i=0; i<10; i++) <br />
printf ("Zahl %d ist: %d\n", i, zahlen[i]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen:''' <br />
Zuerst wird ein 10 int-Variablen großes Array angelegt. <br />
In dieses wird nun der Reihe nach 10 Zahlen eingelesen. <br />
Anschließend werden alle 10 Zahlen ausgegeben. <br />
<br />
{{FarbigerRahmen|<br />
'''Merke:'''<br />
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!<br />
}}<br />
<br />
===Strings (Zeichenketten)===<br />
Ein String ist nichts anderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.<br />
<br />
Die Definition eines Strings erfolgt also genauso wie bei Arrays:<br />
char string[21];<br />
<br />
Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert". <br />
<br />
Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.<br />
<br />
===Mehrdimensionale Arrays===<br />
Manchmal benötigt man mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.<br />
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:<br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int x,y;<br />
int feld[3][5];<br />
<br />
for (x=0; x<3; x++) <br />
{<br />
for (y=0; y<5; y++)<br />
{<br />
printf ("Feldwert x: %d, y: %d ", x, y);<br />
scanf ("%d", & feld[x][y]);<br />
printf ("\n");<br />
}<br />
}<br />
<br />
for(x=0; x<3; x++) <br />
for (y=0; y<5; y++) <br />
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Erklärung:''' <br />
<br />
Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt. <br />
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>. <br />
Zum Schluß werden alle Werte noch einmal ausgegeben.<br />
<br />
===Strukturen===<br />
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden: <br />
<br />
<pre><br />
struct Person <br />
{<br />
int id;<br />
char vname[20], nname[20];<br />
char telnr[15];<br />
int alter;<br />
};<br />
</pre><br />
<br />
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein. <br />
Dann werden in dieser Struktur vier Komponenten angelege: drei Strings und zwei <tt>int</tt>. <br />
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach <br />
struct Person Variablenname;<br />
an. <br />
<br />
Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:<br />
<pre><br />
struct Person hubert, klaus;<br />
<br />
hubert.alter = 32;<br />
klaus.alter = hubert.alter + 1;<br />
</pre><br />
<br />
===Unions===<br />
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.<br />
<pre><br />
union Daten <br />
{<br />
int id;<br />
<br />
struct u_double<br />
{<br />
int id;<br />
double wert;<br />
};<br />
<br />
struct Person u_person;<br />
<br />
struct u_pointer<br />
{<br />
int id;<br />
union Daten * p1;<br />
union Daten * p2;<br />
};<br />
};<br />
<br />
union Daten data;<br />
</pre><br />
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_double</tt>, <tt>u_person</tt> und <tt>u_pointer</tt>. Die Große der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden.<br />
<br />
Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:<br />
<pre><br />
typedef union<br />
{<br />
unsigned long as_long;<br />
unsignen chat as_byte[4];<br />
} data32_t;<br />
</pre><br />
Dies überlagert einen <tt>unsigned long</tt> &ndash; also eine 32-Bit-Zahl &ndash; mit vier Bytes.<br />
<pre><br />
data32_t wert;<br />
<br />
wert.as_long = 0x12345678;<br />
wert.as_byte[0] = 0xab;<br />
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */<br />
</pre><br />
<br />
=Variablen=<br />
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.<br />
<br />
==Variablennamen==<br />
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.<br />
<br />
Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.<br />
==Anlegen von Variablen==<br />
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung! <br />
<pre><br />
int Zahl1, Zahl2;<br />
char Zeichen;<br />
<br />
int main (void)<br />
{<br />
float gleitZahl;<br />
/* Anweisungen */<br />
<br />
return 0;<br />
}<br />
</pre><br />
;Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].<br />
<br />
==Zuweisungen==<br />
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]]. <br />
<pre><br />
int main (void)<br />
{<br />
int zahl1, zahl2 = 12;<br />
char zeichen1 = 'A';<br />
<br />
zahl1 = 52;<br />
zeichen1 = zeichen1 + 1; <br />
<br />
return 0;<br />
}<br />
</pre><br />
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>). <br />
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen. <br />
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.<br />
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.<br />
<br />
==Zuweisungen bei float==<br />
Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt: <br />
floatVariable = 3.14;<br />
Zusätzlich kann eine Zehnerpotenz angegeben werden:<br />
floatVariable2 = -1.234E-6;<br />
Dadurch wird der erst Wert mit 10<sup><tt>-</tt>6</sup> multipliziert, der Wert der Variablen ist also <br />
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.<br />
<br />
==Zuweisungen bei logischen Variablen==<br />
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr". <br />
intVariable = !0; /* entspricht "wahr" */<br />
intVariable = 0; /* entspricht "unwahr" */<br />
<br />
==Vergleich von Variablen==<br />
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln: <br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|}<br />
</center><br />
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl. <br />
intVariable = zahl1 <= zahl2;<br />
das komplette Beispiel zeigt es deutlicher:<br />
<pre><br />
int i;<br />
int z1, z2;<br />
<br />
z1 = 5;<br />
z2 = 100;<br />
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */<br />
<br />
printf ("Ergebnis: %d\n", i);<br />
</pre><br />
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").<br />
<br />
==Konstanten==<br />
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:<br />
const ''datentyp'' name = value; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. <br />
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.<br />
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit<br />
* ((float*) &PI) = 2;<br />
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.<br />
<br />
Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist<br />
void foo (const char * str, ...);<br />
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.<br />
<br />
Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:<br />
void foo (char * const str, ...);<br />
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>. Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim&nbsp;<tt>*</tt> auf: Steht das <tt>const</tt> links vom&nbsp;<tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides &ndash; also den Zeiger und sein Ziel &ndash; als konstant zu markieren.<br />
<br />
==Gültigkeitsbereich==<br />
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln: <br />
<br />
;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.<br />
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.<br />
<br />
==Speicherklassen==<br />
Jede Variable in C gehört zu einer bestimmten Speicherklasse<br />
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.<br />
;<tt>extern</tt>: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].<br />
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.<br />
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable &ndash; falls möglich &ndash; als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!<br />
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.<br />
<br />
=Ausdrücke=<br />
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.<br />
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.<br />
<br />
Einfache Beispiele für Ausdrücke sind also z.B.:<br />
1<br />
a<br />
'a'<br />
1 + a<br />
a == 1<br />
<br />
Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.<br />
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,<br />
und wei man damit neue Ausdrücke aufbauen kann.<br />
<br />
==Lvalues==<br />
<br />
Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.<br />
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.<br />
<br />
Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:<br />
a = 1;<br />
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie<br />
a+1 = 2;<br />
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":<br />
"ungültiger Wert in Zuweisung"<br />
<br />
Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante&nbsp;4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung&nbsp;<tt>*</tt> wird an die Adresse&nbsp;4 im Speicher eine&nbsp;3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.<br />
* ((unsigned int *) 4) = 3;<br />
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue<br />
<br />
==Logische (boolsche) Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a &amp;&amp; b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr<br />
|-<br />
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr<br />
|-<br />
|<tt>a == b</tt> || gleich<br />
|-<br />
|<tt>a != b</tt> || ungleich<br />
|-<br />
|<tt>a <= b</tt> || kleiner oder gleich<br />
|-<br />
|<tt>a < b</tt> || kleiner als<br />
|-<br />
|<tt>a >= b</tt> || glösser oder gleich<br />
|-<br />
|<tt>a > b</tt> || grösser als<br />
|-<br />
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa<br />
|}<br />
</center><br />
<br />
Eine interessante Eigenheit der Operatoren <tt>&amp;&amp;</tt> und <tt>||</tt> ist, dass<br />
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden<br />
dabei immer von links nach rechts ausgewertet.<br />
<br />
Beispiel:<br />
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */<br />
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */<br />
<br />
<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,<br />
die eine aufwändige Operation durchführt.<br />
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder<br />
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.<br />
<br />
Wo ist also der Unterschied?<br><br />
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,<br />
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.<br />
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte<br />
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.<br />
<br />
==Arithmetische Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a + b</tt> || Summe (Addition)<br />
|-<br />
|<tt>a - b</tt> || Differenz (Subtraktion)<br />
|-<br />
|<tt>a * b</tt> || Produkt (Multiplikation)<br />
|-<br />
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)<br />
|-<br />
|<tt>a % b</tt> || Rest bei Division (Modulo)<br />
|-<br />
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)<br />
|}<br />
</center><br />
==Bit-Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a & b</tt> || bitweise und (and)<br />
|-<br />
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)<br />
|-<br />
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)<br />
|-<br />
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)<br />
|}<br />
</center><br />
==Index-Operator bei Arrays==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a<br />
|}<br />
</center><br />
<br />
Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:<br />
<br />
# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein<br />
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)<br />
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!<br />
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung<br />
<br />
==Komponenten-Auswahl bei Structs und Unions==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a<br />
|}<br />
</center><br />
<br />
==Adress-Operator und Dereferenzierung==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>&amp;a</tt> || Speicheradresse der Variablen <tt>a</tt><br />
|-<br />
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht<br />
|-<br />
||<tt>a-&gt;b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht<br />
|}<br />
</center><br />
<br />
Der Adressoperator & kann auf Variablen angewendet werden und<br />
gibt die Startadresse der Variablen im Speicher zurück.<br />
<br />
Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält<br />
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der<br />
an dieser Adresse steht, wird der Operator * vorangestellt.<br />
<br />
Beispiel:<br />
<pre><br />
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */<br />
<br />
/* z ist ein Zeiger auf eine Integervariable und enthält somit<br />
die Speicheradresse einer Integervariablen<br />
*/<br />
int *z; <br />
<br />
/* Verwendung des Adressoperators... */<br />
z = &x; /* weise z die Speicheradresse von x zu */<br />
<br />
/* Verwendung der Dereferenzierung */<br />
/* erhöhe den Wert, der bei Adresse z steht um eins */<br />
*z = *z + 1;<br />
<br />
/* da z auf x zeigt, hat auch x jetzt den Wert 6 */<br />
</pre><br />
<br />
Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff<br />
auf ein Element eine abkürzende Schreibweise möglich:<br />
<br />
Statt <br />
(*strukturZeiger).element<br />
kann geschrieben werden<br />
strukturZeiger->element<br />
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch<br />
auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu<br />
einer Änderung '''irgendeiner''' Speicherstelle:<br />
<br />
<pre><br />
int *z; /* z ist ein Zeiger auf einen Integer */<br />
<br />
/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.<br />
z enthält irgendeine(!) Adresse<br />
*/<br />
<br />
/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */<br />
*z = *z + 1;<br />
</pre><br />
<br />
Viele C-Compiler (z.B. gcc) erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!<br />
}}<br />
<br />
==Cast-Operator==<br />
<br />
Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.<br />
<br />
Um zum Beispiel aus einem Float ein Integer zu machen:<br />
var = (int) 5.60;<br />
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.<br />
<br />
Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:<br />
int * addr;<br />
addr = (int*) 0x1234;<br />
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder<br />
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in<br />
eine Zahl oder umgekehrt zu wandeln:<br />
<br />
<pre><br />
#include <stdio.h><br />
int main(int argc, char ** argv)<br />
{<br />
char text[] = "5.6";<br />
int zahl = (int)text;<br />
<br />
printf("%d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator<br />
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.<br />
}}<br />
<br />
==Komma Operator==<br />
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.<br />
Die Auswertung erfolgt von links nach rechts.<br />
<br />
Solche Konstrukte sieht man manchmal in Abfragen wie<br />
FILE *file;<br />
if (file = fopen ("foo.exe", "r"), file != NULL)<br />
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,<br />
wenn <tt>file</tt> nicht der Nullpointer ist.<br />
<br />
==Zuweisungen und Operatoren mit Nebeneffekt==<br />
===Bedingte Zuweisung===<br />
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;<br />
<br />
<!--<br />
Kein ANSI-C<br />
--[[Benutzer:SprinterSB|SprinterSB]] 17:15, 29. Jun 2006 (CEST)<br />
==Blöcke==<br />
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.<br />
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks. <br />
Der Block muss un runden Klammern stehen:<br />
int sum;<br />
sum = ({<br />
int i, s = 0;<br />
for (i=1; i<= 100; i++)<br />
s += i;<br />
s;<br />
});<br />
<br />
Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc, <br />
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer<br />
Instruktion nicht machbar wäre:<br />
<pre><br />
#define PSTR(s) \<br />
({ \ <br />
static char __c[] PROGMEM = (s); \<br />
__c; \<br />
})<br />
</pre><br />
--><br />
<br />
==Reihenfolge der Auswertung==<br />
<br />
=Kontrollanweisungen=<br />
<br />
==Boolsche Logik==<br />
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird). <br />
<br />
b1= b2 && b3;<br />
<br />
<br />
Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).<br />
<br />
<br />
b1= b2 || b3;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.<br />
<br />
<br />
b1= !b2;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".<br />
<br />
==<tt>if</tt>-Anweisung==<br />
Syntax: IF (Bedingung) Anweisung;<br />
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:<br />
<br />
[[bild:ifthenelse.png]]<br />
<br />
Und in C schreibt man:<br />
<pre><br />
if (Bedingung) /* WENN */<br />
{ /* DANN */<br />
Anweisung1;<br />
Anweisung2;<br />
...<br />
}<br />
else<br />
{ /* SONST */<br />
Anweisung3;<br />
Anweisung4;<br />
...<br />
}<br />
</pre><br />
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt. <br />
<br />
Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki><br />
<br />
<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki><br />
<br />
<br />
Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.<br />
}}<br />
<br />
==<tt>switch</tt>-Anweisung==<br />
Syntax: <br />
<pre><br />
switch(ausdruck) {<br />
case wert1:<br />
Anweisungen1...<br />
case wert2:<br />
Anweisungen2...<br />
case wert3:<br />
Anweisungen3...<br />
...<br />
default:<br />
Anweisungen4...<br />
}<br />
</pre><br />
<br />
Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter<br />
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der<br />
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt><br />
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.<br />
<br />
<b>Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines<br />
<tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!</b><br />
<br />
Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.<br />
Der <tt>default</tt>-Abschnitt ist optional, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,<br />
wenn er verwendet wird.<br />
<br />
<br />
==Schleifen==<br />
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.<br> <br />
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird. <br />
<br />
===<tt>while</tt>-Schleife===<br />
'''Syntax:''' while (Bedingung) { Anweisung; }<br />
<br />
Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block! <br />
<br />
<pre><br />
Zahl1=0;<br />
while (Zahl1<3)<br />
{<br />
Zahl1=Zahl1+1;<br />
Zahl2=Zahl2*2;<br />
}<br />
</pre><br />
<br />
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.<br />
===<tt>do</tt>-<tt>while</tt>-Schleife===<br />
'''Syntax:''' do { Anweisung; }while (Bedingung);<br />
<br />
Die DO WHILE-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird <br />
<br />
<pre><br />
int i=2;<br />
do <br />
{<br />
i = i*i; /* i quadrieren */<br />
printf ("i = %d\n", i);<br />
}<br />
while (i < 20);<br />
</pre><br />
<br />
Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.<br />
<br />
===<tt>for</tt>-Schleife===<br />
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }<br />
<br />
Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.<br />
<br />
Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.<br />
<br />
Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet. <br />
<br />
<pre><br />
int lauf;<br />
int summe = 0;<br />
<br />
for (lauf = 1; lauf <= 10; lauf = lauf+2 ) <br />
{<br />
summe = summe + lauf;<br />
}<br />
</pre><br />
Das Äquivalent als <tt>while</tt>-Schleife:<br />
<pre><br />
int lauf = 1; /* Anfangswerte */<br />
int summe = 0;<br />
<br />
while (lauf <= 10) /* Bedingung */<br />
{<br />
summe = summe + lauf;<br />
lauf += 2; /* Inkrement */<br />
}<br />
</pre><br />
<br />
<br />
In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.<br />
<br />
'''Erklärung:''' <br />
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. <br />
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. <br />
<tt>lauf = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um&nbsp;2 erhöht wird.<br />
<br />
=Ein- und Ausgabe=<br />
<br />
==Bildschirm-Ausgabe==<br />
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.<br />
<br />
Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, </tt>char</tt>, <tt>double</tt>...) sein! <br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int zahl1 = 12;<br />
char zeichen1 = 'A';<br />
<br />
printf ("Das ist Text, und er wird als solcher ausgegeben. \n");<br />
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile. <br />
<br />
Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus. <br />
<br />
In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert. <br />
<br />
Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen! <br />
<br />
==Tastatur-Eingabe==<br />
<br />
Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.<br />
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>: <br />
<br />
<pre><br />
int zahl1;<br />
char zeichen1;<br />
<br />
printf ("Bitte geben Sie eine Zahl ein: ");<br />
scanf ("%d", &zahl1);<br />
printf ("Geben Sie einen Zeichen ein: ");<br />
scanf ("%c", &zeichen1);<br />
</pre><br />
<br />
Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.<br />
<br />
Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!<br />
<br />
Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference"). <br />
<br />
<br />
=Allgemeines zu Unterprogrammen=<br />
Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen.<br />
Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen: <br />
<br />
==Funktionen==<br />
'''Syntax:''' Rückgabe-Typ Name(Parameterliste);<br />
<br />
Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln: <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int hoch2 (int param1)<br />
{<br />
int zahl;<br />
zahl = param1 * param1;<br />
return zahl;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl1, ergebnis;<br />
<br />
printf ("Bitte Zahl eingeben: ");<br />
scanf ("%d",&zahl1);<br />
<br />
ergebnis = hoch2 (zahl1);<br />
<br />
printf ("%d hoch 2 = %d\n",zahl1, ergebnis);<br />
printf ("5 hoch 2 = %d\n", hoch2(5));<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. <br />
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. <br />
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.<br />
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. <br />
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert. <br />
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an<br />
variable = Funktion (Parameter);<br />
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile). <br />
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.<br />
<br />
==Prozedur==<br />
'''Syntax:''' <tt>void Name (Parameterliste)</tt><br />
<br />
Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp <tt>void</tt>, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede: <br />
<br />
Als Rückgabe-Datentyp wird <tt>void</tt> angegeben. <br />
Einer Variablen kann daher nicht der Rückgabewert einer <tt>void</tt>-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int param1)<br />
{<br />
printf ("Der Wert der Variablen ist: %d\n", param1);<br />
}<br />
<br />
int main(void)<br />
{<br />
int zahl1 = 4;<br />
<br />
ausgeben (23);<br />
ausgeben (zahl1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Durch den Befehl "<tt>ausgeben(23)</tt>" wird die Prozedur "<tt>ausgeben</tt>" mit dem Parameter <tt>23</tt> aufgerufen. <tt>param1</tt> hat also den Wert <tt>23</tt>. Die einzige Anweisung innerhalb der Prozedur ist <tt>printf</tt>, was nun ausgeführt wird. <br />
Der zweite Aufruf von <tt>ausgeben</tt> erfolgt mit dem Parameter <tt>zahl1</tt>, also wird <tt>param1</tt> der Wert 4 zugewiesen. Dieser wird nun wieder mittels <tt>printf</tt> ausgeben. <br />
<br />
Unterprogramme ohne Parameter<br />
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur <tt>void</tt> stehen. Das <tt>void</tt> bedeutet "die Funktion erhält keine Parameter". "<tt>void main (void)</tt>" bedeutet also: "Erstelle ein Unterprogramm Namens <tt>main</tt>, das keinen Rückgabewert und keine Parameter hat".<br />
<br />
{{FarbigerRahmen |<br />
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:<br />
foo();<br />
}}<br />
<br />
==Prototypen==<br />
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?<br />
Um dies zu erreichen, gibt es zwei Möglichkeiten: <br />
<br />
Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! <br />
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. <br />
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt&nbsp;<tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). <br />
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int zahl); /* Der Prototyp */<br />
<br />
int main (void)<br />
{<br />
ausgeben (12);<br />
<br />
return 0;<br />
}<br />
<br />
void ausgeben (int zahl) /* Die eigentliche Prozedur */<br />
{<br />
printf ("Ausgabe: %d\n", zahl);<br />
}<br />
</pre><br />
<br />
==Parameterübergabe==<br />
<br />
Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.<br />
Das hat folgende Auswirkungen:<br />
<br />
# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!<br />
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger | Zeiger]] übergeben werden.<br />
# Werden [[#Strukturen | Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.<br />
<br />
<br />
Beispiele:<br />
<pre><br />
void erhoehe (int x)<br />
{<br />
x = x + 1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int a = 0;<br />
erhoehe(a);<br />
/* a ist immer noch 0 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.<br />
<br />
<pre><br />
void erhoehe (int *x)<br />
{<br />
/* erhöhe den Wert an der Adresse x um eins */<br />
*x = *x + 1;<br />
}<br />
<br />
int main(void)<br />
{<br />
int a = 0;<br />
erhoehe (&a);<br />
/* a ist jetzt 1 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&amp;</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die<br />
Adresse des Originals <tt>a</tt> und kann direkt mit dem Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.<br />
<br />
<br />
'''Besonderheit bei Feldern'''<br />
<br />
Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines<br />
Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.<br />
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf<br />
den Originaldaten arbeiten und diese verändern.<br />
<br />
Beispiel:<br />
<pre><br />
void erhoehe (int x[])<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
<br />
Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:<br />
<br />
<pre><br />
/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */<br />
void erhoehe (int *x)<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
}<br />
</pre><br />
<br />
{{FarbigerRahmen |<br />
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.<br />
}}<br />
<br />
=Standard-Funktionen=<br />
<br />
==strcpy==<br />
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren! <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri1[21], eingabe[21];<br />
<br />
strcpy (stri1, "hallo");<br />
<br />
printf ("Der 1. String: %s\n", stri1);<br />
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");<br />
scanf ("%s", eingabe);<br />
strcpy (stri1, eingabe);<br />
printf ("\n%s = %s", stri1, eingabe);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Hinweis:''' <br />
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&amp;</tt> bei <tt>scanf</tt> angeben!<br />
<br />
'''Erklärung:''' <br />
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen. <br />
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. <br />
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings. <br />
Sie werden gebeten, eine String einzugeben. <br />
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert. <br />
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.<br />
<br />
==strlen==<br />
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern. <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri[21];<br />
<br />
strcpy (stri, "hallo");<br />
printf ("Der String ist %d Zeichen lang", strlen (stri));<br />
}<br />
</pre><br />
<br />
Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc. <br />
<br />
<br />
<br />
===Zeiger als Parameter===<br />
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.<br />
Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable"). <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void erhoehe (int *zeiger)<br />
{<br />
*zeiger = *zeiger+1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl;<br />
<br />
printf ("Zahl eingeben: ");<br />
scanf ("%d", &zahl);<br />
erhoehe (&zahl);<br />
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
==Parameter von <tt>main</tt>==<br />
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen. <br />
<pre><br />
int main (int argc, char *argv[], char* environ[])<br />
</pre><br />
<br />
Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge&nbsp;0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.<br />
<pre><br />
#include <stdio.h><br />
#include <stdlib.h><br />
<br />
int main (int argc, char *argv[], char * environ[])<br />
{<br />
int i;<br />
<br />
printf ("Es wurden %d Parameter angegeben", argc);<br />
<br />
for (i=0; i < argc; i++) <br />
printf ("Parameter %d: %s\n", i, argv[i]);<br />
<br />
for (i = 0; environ[i] != NULL; ++i) <br />
printf ("environ[%d] = %s\n", i, environ[i]);<br />
}<br />
</pre><br />
<br />
;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement &ndash; wie in C üblich &ndash; das Element <tt><tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen! <br />
<br />
=Liste der Schlüsselworte=<br />
<br />
* [[#Speicherklassen|auto]]<br />
* break<br />
* [[#Elementare Datentypen|double]]<br />
* [[#Elementare Datentypen|char]]<br />
* case<br />
* [[#Konstanten|const]]<br />
* continue<br />
* default<br />
* do<br />
* else<br />
* enum<br />
* [[#Speicherklassen|extern]]<br />
* [[#Elementare Datentypen|float]]<br />
* for<br />
* goto<br />
* if<br />
* [[##Elementare Datentypen|int]]<br />
* [[#Elementare Datentypen|long]]<br />
* return<br />
* [[#Speicherklassen|register]]<br />
* [[#Elementare Datentypen|short]]<br />
* signed<br />
* sizeof<br />
* [[#Speicherklassen|static]]<br />
* [[#Strukturen|struct]]<br />
* switch<br />
* typedef<br />
* [[#Unions|union]]<br />
* unsigned<br />
* [[#Elementare Datentypen|void]]<br />
* volatile<br />
* while<br />
<br />
Baustelle<br />
<br />
=Liste der Operatoren=<br />
<br />
Baustelle<br />
<br />
<font color="blue"><></font><br />
<br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung || Nebeneffekte<br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> == <font color="blue"><Ausdruck></font></tt> || ist gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> != <font color="blue"><Ausdruck></font></tt> || ist nicht gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt; <font color="blue"><Ausdruck></font></tt> || ist kleiner <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt;= <font color="blue"><Ausdruck></font></tt> || ist kleiner oder gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt; <font color="blue"><Ausdruck></font></tt> || ist größer <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt;= <font color="blue"><Ausdruck></font></tt> || ist größer oder gleich <br />
|-<br />
| <tt>&amp; <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> = <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> += <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> -= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> *= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> /= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ^= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> &= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> |= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>++ <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ++</tt> || <br />
|-<br />
| <tt>-- <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> --</tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> && <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> <nowiki>||</nowiki> <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>~ <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>! <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Type></font>) <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> + <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> - <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> * <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> / <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> % <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> %= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Bedingung></font>) ? <font color="blue"><Ausdruck></font> : <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Struct></font>.<font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Zeiger-auf-Struct></font>-><font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|}<br />
<br />
<br />
'''Autoren'''<br />
* Plasma<br />
* Bernd<br />
* [[Benutzer:SprinterSB|SprinterSB]]<br />
<br />
'''Quellen:'''<br />
* Kernighan und Ritchie - Buch<br />
* Christian Wirth , C Tutorial<br />
* Prof. Dr. J. Dankert Ausführungen<br />
<br />
=Siehe auch=<br />
* [[avr-gcc]]<br />
* [[Compiler]]<br />
* [[WinAVR]]<br />
* [[Fallstricke bei der C-Programmierung]]<br />
<br />
=Weblinks=<br />
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]<br />
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]<br />
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]<br />
<br />
[[Kategorie:Quellcode C|!]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=C-Tutorial&diff=8127C-Tutorial2006-07-05T11:53:23Z<p>Roberto: /* Strings (Zeichenketten) */</p>
<hr />
<div>Ein kurzer Einblick in die Programmiersprache C<br />
=Allgemeines=<br />
C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.<br />
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.<br />
<br />
C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu lediglich einen anderen Compiler, und Inline-Assembler Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden. <br />
<br />
==Geschichte==<br />
;1971: C wird entwickelt<br />
;1978: Kernighan und Ritchie definieren die Sprache.<br />
;1983: ANSI und ISO standardisieren C.<br />
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.<br />
<br />
=Aufbau eines C-Programmes=<br />
<!-- <br />
<br />
C-Programme haben keinen fixen Aufbau wie z.B. Pascal. Es gibt zwar gewisse Regeln, aber sonst sind dem Programmierer alle Freiheiten überlassen. Der folgende "Beispiel-Aufbau" ist daher nicht zwingend und kann durchaus verändert werden.<br />
<br />
Natürlich haben C-Programme einen fixen Aufbau! Ebenso wie Pascal-Programme auch unterliegen sie einer strikten Grammatik! <br />
Auskommentiert --[[Benutzer:SprinterSB|SprinterSB]] 10:23, 17. Feb 2006 (CET)<br />
--><br />
Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau. <br />
<pre><br />
#include <stdio.h><br />
<br />
int Zahl1;<br />
char Zeichen1;<br />
<br />
int main (void)<br />
{<br />
int zahl2;<br />
<br />
/* Anweisungen */<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Beschreibung (die Erklärungen folgen): <br />
<br />
;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.<br />
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.<br />
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert. <br />
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.<br />
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.<br />
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert. <br />
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.<br />
;return 0;: Gibt den Wert&nbsp;0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.<br />
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.<br />
<br />
=Das Hauptprogramm main=<br />
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm. <br />
<br />
Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer &ndash; üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt. <br />
<br />
Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!<br />
<pre><br />
/* <br />
* void Definition von main ist nur beim Controller üblich<br />
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main<br />
* kein Fehler/Warnung erzeugt wird. <br />
*/<br />
void main (void)<br />
{<br />
...<br />
}<br />
</pre><br />
<br />
=Blöcke=<br />
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung.<br />
Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende": <br />
<br />
<pre><br />
int main (void)<br />
{ /* der Block "main" beginnt */<br />
int zahl;<br />
<br />
{ /* ein Block beginnt */<br />
/* hier können Deklarationen und Anweisungen stehen */<br />
} /* der Block endet */<br />
<br />
return 0;<br />
} /* "main" endet */<br />
</pre><br />
<br />
'''Bemerkung:''' <br />
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!<br />
<br />
=Datentypen=<br />
==Elementare Datentypen==<br />
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.<br />
<br />
;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!<br />
<br />
===int, char, short, long (ganze Zahlen)===<br />
In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen. <br />
<br />
Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann reicht der Wertebereich von <tt>-2<sup>''b''-1</sup></tt> bis zu <tt>2<sup>''b''-1</sup>-1</tt>.<br />
<br />
Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2<sup>''b''</sup>-1</tt>, wenn der Typ ''b'' Bits breit ist.<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs<br />
|- <br />
| 8 || <tt>char</tt> <br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -128<br />0<br />
| align="right" | 127<br />255<br />
|- <br />
| 16 || <tt>short</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -32.768<br />0<br />
| align="right" | 32.767<br />65.535<br />
|- <br />
| 32 || <tt>long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -2.147.483.648<br />0<br />
| align="right" | 2.147.483.647<br />4.294.967.295<br />
|- <br />
| 64 || <tt>long long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -9.223.372.036.854.775.808<br />0<br />
| align="right" | 9.223.372.036.854.775.807<br />18.446.744.073.709.551.615<br />
|-<br />
|8, 16, 32, 64<br/><br />
| <tt>int</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
|plattform-/compilerabhängig<br />
|plattform-/compilerabhängig<br />
|}<br />
</center><br />
<br />
==== Boolean (Logische Variablen)====<br />
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.<br />
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.<br />
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert&nbsp;1 haben muß. Sie muß lediglich ungleich&nbsp;0 sein!<br />
<br />
====char (Zeichen)====<br />
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen. <br />
<br />
Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!<br />
<br />
===float, double (Gleitkommazahlen)===<br />
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. <br />
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.<br />
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.<br />
<br />
===void===<br />
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.<br />
<br />
==Zeiger==<br />
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''. <br />
<br />
Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein&nbsp;<tt>&</tt> voranstellt. Die Umkehrung davon &ndash; also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist &ndash; erledigt ein vorgestellter&nbsp;<tt>*</tt>. Der Operator &nbsp;<tt>*</tt> gibt also den ''Inhalt'' der Adresse.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int * zeiger;<br />
int zahl;<br />
<br />
zeiger = &zahl;<br />
*zeiger = 12;<br />
<br />
printf ("%d = %d", zahl, *zeiger);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der&nbsp;<tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:<br />
int * zeiger, zahl;<br />
<br />
Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator&nbsp;<tt>&</tt> von <tt>zahl</tt>:<br />
zeiger = &zahl; <br />
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>). <br />
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.<br />
<br />
==Zusammengesetzte Datentypen==<br />
===Arrays===<br />
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays &ndash; teilweise auch als ''Felder'' bezeichnet &ndash; zu verwenden.<br />
<br />
In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> arbeiten!<br />
<br />
'''Syntax:''' Datentyp Variablenname[Anzahl]<br />
<br />
Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für 3 Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes. <br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int i;<br />
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */<br />
<br />
for (i=0; i<10; i++)<br />
{<br />
printf ("Bitte Zahl %d eingeben: ", i);<br />
scanf ("%d", & zahlen[i]);<br />
printf ("\n");<br />
}<br />
printf ("Super!\n");<br />
<br />
for (i=0; i<10; i++) <br />
printf ("Zahl %d ist: %d\n", i, zahlen[i]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen:''' <br />
Zuerst wird ein 10 int-Variablen großes Array angelegt. <br />
In dieses wird nun der Reihe nach 10 Zahlen eingelesen. <br />
Anschließend werden alle 10 Zahlen ausgegeben. <br />
<br />
{{FarbigerRahmen|<br />
'''Merke:'''<br />
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!<br />
}}<br />
<br />
===Strings (Zeichenketten)===<br />
Ein String ist nichts anderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.<br />
<br />
Die Definition eines Strings erfolgt also genauso wie bei Arrays:<br />
char string[21];<br />
<br />
Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert". <br />
<br />
Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.<br />
<br />
===Mehrdimensionale Arrays===<br />
Manchmal benötigen mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.<br />
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:<br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int x,y;<br />
int feld[3][5];<br />
<br />
for (x=0; x<3; x++) <br />
{<br />
for (y=0; y<5; y++)<br />
{<br />
printf ("Feldwert x: %d, y: %d ", x, y);<br />
scanf ("%d", & feld[x][y]);<br />
printf ("\n");<br />
}<br />
}<br />
<br />
for(x=0; x<3; x++) <br />
for (y=0; y<5; y++) <br />
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Erklärung:''' <br />
<br />
Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt. <br />
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>. <br />
Zum Schluß werden alle Werte noch einmal ausgegeben.<br />
<br />
===Strukturen===<br />
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden: <br />
<br />
<pre><br />
struct Person <br />
{<br />
int id;<br />
char vname[20], nname[20];<br />
char telnr[15];<br />
int alter;<br />
};<br />
</pre><br />
<br />
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein. <br />
Dann werden in dieser Struktur vier Komponenten angelege: drei Strings und zwei <tt>int</tt>. <br />
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach <br />
struct Person Variablenname;<br />
an. <br />
<br />
Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:<br />
<pre><br />
struct Person hubert, klaus;<br />
<br />
hubert.alter = 32;<br />
klaus.alter = hubert.alter + 1;<br />
</pre><br />
<br />
===Unions===<br />
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.<br />
<pre><br />
union Daten <br />
{<br />
int id;<br />
<br />
struct u_double<br />
{<br />
int id;<br />
double wert;<br />
};<br />
<br />
struct Person u_person;<br />
<br />
struct u_pointer<br />
{<br />
int id;<br />
union Daten * p1;<br />
union Daten * p2;<br />
};<br />
};<br />
<br />
union Daten data;<br />
</pre><br />
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_double</tt>, <tt>u_person</tt> und <tt>u_pointer</tt>. Die Große der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden.<br />
<br />
Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:<br />
<pre><br />
typedef union<br />
{<br />
unsigned long as_long;<br />
unsignen chat as_byte[4];<br />
} data32_t;<br />
</pre><br />
Dies überlagert einen <tt>unsigned long</tt> &ndash; also eine 32-Bit-Zahl &ndash; mit vier Bytes.<br />
<pre><br />
data32_t wert;<br />
<br />
wert.as_long = 0x12345678;<br />
wert.as_byte[0] = 0xab;<br />
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */<br />
</pre><br />
<br />
=Variablen=<br />
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.<br />
<br />
==Variablennamen==<br />
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.<br />
<br />
Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.<br />
==Anlegen von Variablen==<br />
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung! <br />
<pre><br />
int Zahl1, Zahl2;<br />
char Zeichen;<br />
<br />
int main (void)<br />
{<br />
float gleitZahl;<br />
/* Anweisungen */<br />
<br />
return 0;<br />
}<br />
</pre><br />
;Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].<br />
<br />
==Zuweisungen==<br />
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]]. <br />
<pre><br />
int main (void)<br />
{<br />
int zahl1, zahl2 = 12;<br />
char zeichen1 = 'A';<br />
<br />
zahl1 = 52;<br />
zeichen1 = zeichen1 + 1; <br />
<br />
return 0;<br />
}<br />
</pre><br />
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>). <br />
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen. <br />
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.<br />
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.<br />
<br />
==Zuweisungen bei float==<br />
Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt: <br />
floatVariable = 3.14;<br />
Zusätzlich kann eine Zehnerpotenz angegeben werden:<br />
floatVariable2 = -1.234E-6;<br />
Dadurch wird der erst Wert mit 10<sup><tt>-</tt>6</sup> multipliziert, der Wert der Variablen ist also <br />
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.<br />
<br />
==Zuweisungen bei logischen Variablen==<br />
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr". <br />
intVariable = !0; /* entspricht "wahr" */<br />
intVariable = 0; /* entspricht "unwahr" */<br />
<br />
==Vergleich von Variablen==<br />
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln: <br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|}<br />
</center><br />
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl. <br />
intVariable = zahl1 <= zahl2;<br />
das komplette Beispiel zeigt es deutlicher:<br />
<pre><br />
int i;<br />
int z1, z2;<br />
<br />
z1 = 5;<br />
z2 = 100;<br />
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */<br />
<br />
printf ("Ergebnis: %d\n", i);<br />
</pre><br />
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").<br />
<br />
==Konstanten==<br />
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:<br />
const ''datentyp'' name = value; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. <br />
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.<br />
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit<br />
* ((float*) &PI) = 2;<br />
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.<br />
<br />
Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist<br />
void foo (const char * str, ...);<br />
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.<br />
<br />
Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:<br />
void foo (char * const str, ...);<br />
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>. Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim&nbsp;<tt>*</tt> auf: Steht das <tt>const</tt> links vom&nbsp;<tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides &ndash; also den Zeiger und sein Ziel &ndash; als konstant zu markieren.<br />
<br />
==Gültigkeitsbereich==<br />
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln: <br />
<br />
;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.<br />
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.<br />
<br />
==Speicherklassen==<br />
Jede Variable in C gehört zu einer bestimmten Speicherklasse<br />
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.<br />
;<tt>extern</tt>: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].<br />
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.<br />
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable &ndash; falls möglich &ndash; als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!<br />
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.<br />
<br />
=Ausdrücke=<br />
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.<br />
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.<br />
<br />
Einfache Beispiele für Ausdrücke sind also z.B.:<br />
1<br />
a<br />
'a'<br />
1 + a<br />
a == 1<br />
<br />
Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.<br />
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,<br />
und wei man damit neue Ausdrücke aufbauen kann.<br />
<br />
==Lvalues==<br />
<br />
Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.<br />
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.<br />
<br />
Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:<br />
a = 1;<br />
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie<br />
a+1 = 2;<br />
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":<br />
"ungültiger Wert in Zuweisung"<br />
<br />
Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante&nbsp;4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung&nbsp;<tt>*</tt> wird an die Adresse&nbsp;4 im Speicher eine&nbsp;3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.<br />
* ((unsigned int *) 4) = 3;<br />
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue<br />
<br />
==Logische (boolsche) Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a &amp;&amp; b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr<br />
|-<br />
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr<br />
|-<br />
|<tt>a == b</tt> || gleich<br />
|-<br />
|<tt>a != b</tt> || ungleich<br />
|-<br />
|<tt>a <= b</tt> || kleiner oder gleich<br />
|-<br />
|<tt>a < b</tt> || kleiner als<br />
|-<br />
|<tt>a >= b</tt> || glösser oder gleich<br />
|-<br />
|<tt>a > b</tt> || grösser als<br />
|-<br />
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa<br />
|}<br />
</center><br />
<br />
Eine interessante Eigenheit der Operatoren <tt>&amp;&amp;</tt> und <tt>||</tt> ist, dass<br />
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden<br />
dabei immer von links nach rechts ausgewertet.<br />
<br />
Beispiel:<br />
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */<br />
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */<br />
<br />
<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,<br />
die eine aufwändige Operation durchführt.<br />
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder<br />
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.<br />
<br />
Wo ist also der Unterschied?<br><br />
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,<br />
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.<br />
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte<br />
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.<br />
<br />
==Arithmetische Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a + b</tt> || Summe (Addition)<br />
|-<br />
|<tt>a - b</tt> || Differenz (Subtraktion)<br />
|-<br />
|<tt>a * b</tt> || Produkt (Multiplikation)<br />
|-<br />
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)<br />
|-<br />
|<tt>a % b</tt> || Rest bei Division (Modulo)<br />
|-<br />
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)<br />
|}<br />
</center><br />
==Bit-Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a & b</tt> || bitweise und (and)<br />
|-<br />
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)<br />
|-<br />
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)<br />
|-<br />
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)<br />
|}<br />
</center><br />
==Index-Operator bei Arrays==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a<br />
|}<br />
</center><br />
<br />
Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:<br />
<br />
# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein<br />
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)<br />
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!<br />
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung<br />
<br />
==Komponenten-Auswahl bei Structs und Unions==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a<br />
|}<br />
</center><br />
<br />
==Adress-Operator und Dereferenzierung==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>&amp;a</tt> || Speicheradresse der Variablen <tt>a</tt><br />
|-<br />
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht<br />
|-<br />
||<tt>a-&gt;b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht<br />
|}<br />
</center><br />
<br />
Der Adressoperator & kann auf Variablen angewendet werden und<br />
gibt die Startadresse der Variablen im Speicher zurück.<br />
<br />
Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält<br />
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der<br />
an dieser Adresse steht, wird der Operator * vorangestellt.<br />
<br />
Beispiel:<br />
<pre><br />
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */<br />
<br />
/* z ist ein Zeiger auf eine Integervariable und enthält somit<br />
die Speicheradresse einer Integervariablen<br />
*/<br />
int *z; <br />
<br />
/* Verwendung des Adressoperators... */<br />
z = &x; /* weise z die Speicheradresse von x zu */<br />
<br />
/* Verwendung der Dereferenzierung */<br />
/* erhöhe den Wert, der bei Adresse z steht um eins */<br />
*z = *z + 1;<br />
<br />
/* da z auf x zeigt, hat auch x jetzt den Wert 6 */<br />
</pre><br />
<br />
Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff<br />
auf ein Element eine abkürzende Schreibweise möglich:<br />
<br />
Statt <br />
(*strukturZeiger).element<br />
kann geschrieben werden<br />
strukturZeiger->element<br />
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch<br />
auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu<br />
einer Änderung '''irgendeiner''' Speicherstelle:<br />
<br />
<pre><br />
int *z; /* z ist ein Zeiger auf einen Integer */<br />
<br />
/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.<br />
z enthält irgendeine(!) Adresse<br />
*/<br />
<br />
/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */<br />
*z = *z + 1;<br />
</pre><br />
<br />
Viele C-Compiler (z.B. gcc) erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!<br />
}}<br />
<br />
==Cast-Operator==<br />
<br />
Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.<br />
<br />
Um zum Beispiel aus einem Float ein Integer zu machen:<br />
var = (int) 5.60;<br />
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.<br />
<br />
Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:<br />
int * addr;<br />
addr = (int*) 0x1234;<br />
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder<br />
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in<br />
eine Zahl oder umgekehrt zu wandeln:<br />
<br />
<pre><br />
#include <stdio.h><br />
int main(int argc, char ** argv)<br />
{<br />
char text[] = "5.6";<br />
int zahl = (int)text;<br />
<br />
printf("%d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator<br />
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.<br />
}}<br />
<br />
==Komma Operator==<br />
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.<br />
Die Auswertung erfolgt von links nach rechts.<br />
<br />
Solche Konstrukte sieht man manchmal in Abfragen wie<br />
FILE *file;<br />
if (file = fopen ("foo.exe", "r"), file != NULL)<br />
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,<br />
wenn <tt>file</tt> nicht der Nullpointer ist.<br />
<br />
==Zuweisungen und Operatoren mit Nebeneffekt==<br />
===Bedingte Zuweisung===<br />
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;<br />
<br />
<!--<br />
Kein ANSI-C<br />
--[[Benutzer:SprinterSB|SprinterSB]] 17:15, 29. Jun 2006 (CEST)<br />
==Blöcke==<br />
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.<br />
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks. <br />
Der Block muss un runden Klammern stehen:<br />
int sum;<br />
sum = ({<br />
int i, s = 0;<br />
for (i=1; i<= 100; i++)<br />
s += i;<br />
s;<br />
});<br />
<br />
Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc, <br />
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer<br />
Instruktion nicht machbar wäre:<br />
<pre><br />
#define PSTR(s) \<br />
({ \ <br />
static char __c[] PROGMEM = (s); \<br />
__c; \<br />
})<br />
</pre><br />
--><br />
<br />
==Reihenfolge der Auswertung==<br />
<br />
=Kontrollanweisungen=<br />
<br />
==Boolsche Logik==<br />
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird). <br />
<br />
b1= b2 && b3;<br />
<br />
<br />
Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).<br />
<br />
<br />
b1= b2 || b3;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.<br />
<br />
<br />
b1= !b2;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".<br />
<br />
==<tt>if</tt>-Anweisung==<br />
Syntax: IF (Bedingung) Anweisung;<br />
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:<br />
<br />
[[bild:ifthenelse.png]]<br />
<br />
Und in C schreibt man:<br />
<pre><br />
if (Bedingung) /* WENN */<br />
{ /* DANN */<br />
Anweisung1;<br />
Anweisung2;<br />
...<br />
}<br />
else<br />
{ /* SONST */<br />
Anweisung3;<br />
Anweisung4;<br />
...<br />
}<br />
</pre><br />
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt. <br />
<br />
Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki><br />
<br />
<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki><br />
<br />
<br />
Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.<br />
}}<br />
<br />
==<tt>switch</tt>-Anweisung==<br />
Syntax: <br />
<pre><br />
switch(ausdruck) {<br />
case wert1:<br />
Anweisungen1...<br />
case wert2:<br />
Anweisungen2...<br />
case wert3:<br />
Anweisungen3...<br />
...<br />
default:<br />
Anweisungen4...<br />
}<br />
</pre><br />
<br />
Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter<br />
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der<br />
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt><br />
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.<br />
<br />
<b>Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines<br />
<tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!</b><br />
<br />
Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.<br />
Der <tt>default</tt>-Abschnitt ist optional, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,<br />
wenn er verwendet wird.<br />
<br />
<br />
==Schleifen==<br />
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.<br> <br />
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird. <br />
<br />
===<tt>while</tt>-Schleife===<br />
'''Syntax:''' while (Bedingung) { Anweisung; }<br />
<br />
Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block! <br />
<br />
<pre><br />
Zahl1=0;<br />
while (Zahl1<3)<br />
{<br />
Zahl1=Zahl1+1;<br />
Zahl2=Zahl2*2;<br />
}<br />
</pre><br />
<br />
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.<br />
===<tt>do</tt>-<tt>while</tt>-Schleife===<br />
'''Syntax:''' do { Anweisung; }while (Bedingung);<br />
<br />
Die DO WHILE-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird <br />
<br />
<pre><br />
int i=2;<br />
do <br />
{<br />
i = i*i; /* i quadrieren */<br />
printf ("i = %d\n", i);<br />
}<br />
while (i < 20);<br />
</pre><br />
<br />
Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.<br />
<br />
===<tt>for</tt>-Schleife===<br />
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }<br />
<br />
Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.<br />
<br />
Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.<br />
<br />
Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet. <br />
<br />
<pre><br />
int lauf;<br />
int summe = 0;<br />
<br />
for (lauf = 1; lauf <= 10; lauf = lauf+2 ) <br />
{<br />
summe = summe + lauf;<br />
}<br />
</pre><br />
Das Äquivalent als <tt>while</tt>-Schleife:<br />
<pre><br />
int lauf = 1; /* Anfangswerte */<br />
int summe = 0;<br />
<br />
while (lauf <= 10) /* Bedingung */<br />
{<br />
summe = summe + lauf;<br />
lauf += 2; /* Inkrement */<br />
}<br />
</pre><br />
<br />
<br />
In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.<br />
<br />
'''Erklärung:''' <br />
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. <br />
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. <br />
<tt>lauf = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um&nbsp;2 erhöht wird.<br />
<br />
=Ein- und Ausgabe=<br />
<br />
==Bildschirm-Ausgabe==<br />
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.<br />
<br />
Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, </tt>char</tt>, <tt>double</tt>...) sein! <br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int zahl1 = 12;<br />
char zeichen1 = 'A';<br />
<br />
printf ("Das ist Text, und er wird als solcher ausgegeben. \n");<br />
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile. <br />
<br />
Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus. <br />
<br />
In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert. <br />
<br />
Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen! <br />
<br />
==Tastatur-Eingabe==<br />
<br />
Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.<br />
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>: <br />
<br />
<pre><br />
int zahl1;<br />
char zeichen1;<br />
<br />
printf ("Bitte geben Sie eine Zahl ein: ");<br />
scanf ("%d", &zahl1);<br />
printf ("Geben Sie einen Zeichen ein: ");<br />
scanf ("%c", &zeichen1);<br />
</pre><br />
<br />
Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.<br />
<br />
Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!<br />
<br />
Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference"). <br />
<br />
<br />
=Allgemeines zu Unterprogrammen=<br />
Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen.<br />
Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen: <br />
<br />
==Funktionen==<br />
'''Syntax:''' Rückgabe-Typ Name(Parameterliste);<br />
<br />
Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln: <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int hoch2 (int param1)<br />
{<br />
int zahl;<br />
zahl = param1 * param1;<br />
return zahl;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl1, ergebnis;<br />
<br />
printf ("Bitte Zahl eingeben: ");<br />
scanf ("%d",&zahl1);<br />
<br />
ergebnis = hoch2 (zahl1);<br />
<br />
printf ("%d hoch 2 = %d\n",zahl1, ergebnis);<br />
printf ("5 hoch 2 = %d\n", hoch2(5));<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. <br />
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. <br />
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.<br />
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. <br />
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert. <br />
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an<br />
variable = Funktion (Parameter);<br />
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile). <br />
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.<br />
<br />
==Prozedur==<br />
'''Syntax:''' <tt>void Name (Parameterliste)</tt><br />
<br />
Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp <tt>void</tt>, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede: <br />
<br />
Als Rückgabe-Datentyp wird <tt>void</tt> angegeben. <br />
Einer Variablen kann daher nicht der Rückgabewert einer <tt>void</tt>-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int param1)<br />
{<br />
printf ("Der Wert der Variablen ist: %d\n", param1);<br />
}<br />
<br />
int main(void)<br />
{<br />
int zahl1 = 4;<br />
<br />
ausgeben (23);<br />
ausgeben (zahl1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Durch den Befehl "<tt>ausgeben(23)</tt>" wird die Prozedur "<tt>ausgeben</tt>" mit dem Parameter <tt>23</tt> aufgerufen. <tt>param1</tt> hat also den Wert <tt>23</tt>. Die einzige Anweisung innerhalb der Prozedur ist <tt>printf</tt>, was nun ausgeführt wird. <br />
Der zweite Aufruf von <tt>ausgeben</tt> erfolgt mit dem Parameter <tt>zahl1</tt>, also wird <tt>param1</tt> der Wert 4 zugewiesen. Dieser wird nun wieder mittels <tt>printf</tt> ausgeben. <br />
<br />
Unterprogramme ohne Parameter<br />
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur <tt>void</tt> stehen. Das <tt>void</tt> bedeutet "die Funktion erhält keine Parameter". "<tt>void main (void)</tt>" bedeutet also: "Erstelle ein Unterprogramm Namens <tt>main</tt>, das keinen Rückgabewert und keine Parameter hat".<br />
<br />
{{FarbigerRahmen |<br />
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:<br />
foo();<br />
}}<br />
<br />
==Prototypen==<br />
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?<br />
Um dies zu erreichen, gibt es zwei Möglichkeiten: <br />
<br />
Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! <br />
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. <br />
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt&nbsp;<tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). <br />
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int zahl); /* Der Prototyp */<br />
<br />
int main (void)<br />
{<br />
ausgeben (12);<br />
<br />
return 0;<br />
}<br />
<br />
void ausgeben (int zahl) /* Die eigentliche Prozedur */<br />
{<br />
printf ("Ausgabe: %d\n", zahl);<br />
}<br />
</pre><br />
<br />
==Parameterübergabe==<br />
<br />
Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.<br />
Das hat folgende Auswirkungen:<br />
<br />
# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!<br />
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger | Zeiger]] übergeben werden.<br />
# Werden [[#Strukturen | Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.<br />
<br />
<br />
Beispiele:<br />
<pre><br />
void erhoehe (int x)<br />
{<br />
x = x + 1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int a = 0;<br />
erhoehe(a);<br />
/* a ist immer noch 0 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.<br />
<br />
<pre><br />
void erhoehe (int *x)<br />
{<br />
/* erhöhe den Wert an der Adresse x um eins */<br />
*x = *x + 1;<br />
}<br />
<br />
int main(void)<br />
{<br />
int a = 0;<br />
erhoehe (&a);<br />
/* a ist jetzt 1 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&amp;</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die<br />
Adresse des Originals <tt>a</tt> und kann direkt mit dem Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.<br />
<br />
<br />
'''Besonderheit bei Feldern'''<br />
<br />
Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines<br />
Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.<br />
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf<br />
den Originaldaten arbeiten und diese verändern.<br />
<br />
Beispiel:<br />
<pre><br />
void erhoehe (int x[])<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
<br />
Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:<br />
<br />
<pre><br />
/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */<br />
void erhoehe (int *x)<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
}<br />
</pre><br />
<br />
{{FarbigerRahmen |<br />
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.<br />
}}<br />
<br />
=Standard-Funktionen=<br />
<br />
==strcpy==<br />
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren! <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri1[21], eingabe[21];<br />
<br />
strcpy (stri1, "hallo");<br />
<br />
printf ("Der 1. String: %s\n", stri1);<br />
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");<br />
scanf ("%s", eingabe);<br />
strcpy (stri1, eingabe);<br />
printf ("\n%s = %s", stri1, eingabe);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Hinweis:''' <br />
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&amp;</tt> bei <tt>scanf</tt> angeben!<br />
<br />
'''Erklärung:''' <br />
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen. <br />
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. <br />
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings. <br />
Sie werden gebeten, eine String einzugeben. <br />
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert. <br />
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.<br />
<br />
==strlen==<br />
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern. <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri[21];<br />
<br />
strcpy (stri, "hallo");<br />
printf ("Der String ist %d Zeichen lang", strlen (stri));<br />
}<br />
</pre><br />
<br />
Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc. <br />
<br />
<br />
<br />
===Zeiger als Parameter===<br />
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.<br />
Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable"). <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void erhoehe (int *zeiger)<br />
{<br />
*zeiger = *zeiger+1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl;<br />
<br />
printf ("Zahl eingeben: ");<br />
scanf ("%d", &zahl);<br />
erhoehe (&zahl);<br />
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
==Parameter von <tt>main</tt>==<br />
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen. <br />
<pre><br />
int main (int argc, char *argv[], char* environ[])<br />
</pre><br />
<br />
Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge&nbsp;0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.<br />
<pre><br />
#include <stdio.h><br />
#include <stdlib.h><br />
<br />
int main (int argc, char *argv[], char * environ[])<br />
{<br />
int i;<br />
<br />
printf ("Es wurden %d Parameter angegeben", argc);<br />
<br />
for (i=0; i < argc; i++) <br />
printf ("Parameter %d: %s\n", i, argv[i]);<br />
<br />
for (i = 0; environ[i] != NULL; ++i) <br />
printf ("environ[%d] = %s\n", i, environ[i]);<br />
}<br />
</pre><br />
<br />
;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement &ndash; wie in C üblich &ndash; das Element <tt><tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen! <br />
<br />
=Liste der Schlüsselworte=<br />
<br />
* [[#Speicherklassen|auto]]<br />
* break<br />
* [[#Elementare Datentypen|double]]<br />
* [[#Elementare Datentypen|char]]<br />
* case<br />
* [[#Konstanten|const]]<br />
* continue<br />
* default<br />
* do<br />
* else<br />
* enum<br />
* [[#Speicherklassen|extern]]<br />
* [[#Elementare Datentypen|float]]<br />
* for<br />
* goto<br />
* if<br />
* [[##Elementare Datentypen|int]]<br />
* [[#Elementare Datentypen|long]]<br />
* return<br />
* [[#Speicherklassen|register]]<br />
* [[#Elementare Datentypen|short]]<br />
* signed<br />
* sizeof<br />
* [[#Speicherklassen|static]]<br />
* [[#Strukturen|struct]]<br />
* switch<br />
* typedef<br />
* [[#Unions|union]]<br />
* unsigned<br />
* [[#Elementare Datentypen|void]]<br />
* volatile<br />
* while<br />
<br />
Baustelle<br />
<br />
=Liste der Operatoren=<br />
<br />
Baustelle<br />
<br />
<font color="blue"><></font><br />
<br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung || Nebeneffekte<br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> == <font color="blue"><Ausdruck></font></tt> || ist gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> != <font color="blue"><Ausdruck></font></tt> || ist nicht gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt; <font color="blue"><Ausdruck></font></tt> || ist kleiner <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt;= <font color="blue"><Ausdruck></font></tt> || ist kleiner oder gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt; <font color="blue"><Ausdruck></font></tt> || ist größer <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt;= <font color="blue"><Ausdruck></font></tt> || ist größer oder gleich <br />
|-<br />
| <tt>&amp; <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> = <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> += <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> -= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> *= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> /= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ^= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> &= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> |= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>++ <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ++</tt> || <br />
|-<br />
| <tt>-- <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> --</tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> && <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> <nowiki>||</nowiki> <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>~ <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>! <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Type></font>) <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> + <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> - <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> * <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> / <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> % <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> %= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Bedingung></font>) ? <font color="blue"><Ausdruck></font> : <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Struct></font>.<font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Zeiger-auf-Struct></font>-><font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|}<br />
<br />
<br />
'''Autoren'''<br />
* Plasma<br />
* Bernd<br />
* [[Benutzer:SprinterSB|SprinterSB]]<br />
<br />
'''Quellen:'''<br />
* Kernighan und Ritchie - Buch<br />
* Christian Wirth , C Tutorial<br />
* Prof. Dr. J. Dankert Ausführungen<br />
<br />
=Siehe auch=<br />
* [[avr-gcc]]<br />
* [[Compiler]]<br />
* [[WinAVR]]<br />
* [[Fallstricke bei der C-Programmierung]]<br />
<br />
=Weblinks=<br />
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]<br />
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]<br />
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]<br />
<br />
[[Kategorie:Quellcode C|!]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=C-Tutorial&diff=8126C-Tutorial2006-07-05T11:47:38Z<p>Roberto: /* Arrays */</p>
<hr />
<div>Ein kurzer Einblick in die Programmiersprache C<br />
=Allgemeines=<br />
C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.<br />
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.<br />
<br />
C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu lediglich einen anderen Compiler, und Inline-Assembler Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden. <br />
<br />
==Geschichte==<br />
;1971: C wird entwickelt<br />
;1978: Kernighan und Ritchie definieren die Sprache.<br />
;1983: ANSI und ISO standardisieren C.<br />
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.<br />
<br />
=Aufbau eines C-Programmes=<br />
<!-- <br />
<br />
C-Programme haben keinen fixen Aufbau wie z.B. Pascal. Es gibt zwar gewisse Regeln, aber sonst sind dem Programmierer alle Freiheiten überlassen. Der folgende "Beispiel-Aufbau" ist daher nicht zwingend und kann durchaus verändert werden.<br />
<br />
Natürlich haben C-Programme einen fixen Aufbau! Ebenso wie Pascal-Programme auch unterliegen sie einer strikten Grammatik! <br />
Auskommentiert --[[Benutzer:SprinterSB|SprinterSB]] 10:23, 17. Feb 2006 (CET)<br />
--><br />
Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau. <br />
<pre><br />
#include <stdio.h><br />
<br />
int Zahl1;<br />
char Zeichen1;<br />
<br />
int main (void)<br />
{<br />
int zahl2;<br />
<br />
/* Anweisungen */<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Beschreibung (die Erklärungen folgen): <br />
<br />
;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.<br />
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.<br />
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert. <br />
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.<br />
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.<br />
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert. <br />
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.<br />
;return 0;: Gibt den Wert&nbsp;0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.<br />
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.<br />
<br />
=Das Hauptprogramm main=<br />
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm. <br />
<br />
Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer &ndash; üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt. <br />
<br />
Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!<br />
<pre><br />
/* <br />
* void Definition von main ist nur beim Controller üblich<br />
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main<br />
* kein Fehler/Warnung erzeugt wird. <br />
*/<br />
void main (void)<br />
{<br />
...<br />
}<br />
</pre><br />
<br />
=Blöcke=<br />
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung.<br />
Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende": <br />
<br />
<pre><br />
int main (void)<br />
{ /* der Block "main" beginnt */<br />
int zahl;<br />
<br />
{ /* ein Block beginnt */<br />
/* hier können Deklarationen und Anweisungen stehen */<br />
} /* der Block endet */<br />
<br />
return 0;<br />
} /* "main" endet */<br />
</pre><br />
<br />
'''Bemerkung:''' <br />
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!<br />
<br />
=Datentypen=<br />
==Elementare Datentypen==<br />
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.<br />
<br />
;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!<br />
<br />
===int, char, short, long (ganze Zahlen)===<br />
In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen. <br />
<br />
Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann reicht der Wertebereich von <tt>-2<sup>''b''-1</sup></tt> bis zu <tt>2<sup>''b''-1</sup>-1</tt>.<br />
<br />
Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2<sup>''b''</sup>-1</tt>, wenn der Typ ''b'' Bits breit ist.<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs<br />
|- <br />
| 8 || <tt>char</tt> <br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -128<br />0<br />
| align="right" | 127<br />255<br />
|- <br />
| 16 || <tt>short</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -32.768<br />0<br />
| align="right" | 32.767<br />65.535<br />
|- <br />
| 32 || <tt>long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -2.147.483.648<br />0<br />
| align="right" | 2.147.483.647<br />4.294.967.295<br />
|- <br />
| 64 || <tt>long long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -9.223.372.036.854.775.808<br />0<br />
| align="right" | 9.223.372.036.854.775.807<br />18.446.744.073.709.551.615<br />
|-<br />
|8, 16, 32, 64<br/><br />
| <tt>int</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
|plattform-/compilerabhängig<br />
|plattform-/compilerabhängig<br />
|}<br />
</center><br />
<br />
==== Boolean (Logische Variablen)====<br />
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.<br />
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.<br />
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert&nbsp;1 haben muß. Sie muß lediglich ungleich&nbsp;0 sein!<br />
<br />
====char (Zeichen)====<br />
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen. <br />
<br />
Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!<br />
<br />
===float, double (Gleitkommazahlen)===<br />
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. <br />
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.<br />
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.<br />
<br />
===void===<br />
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.<br />
<br />
==Zeiger==<br />
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''. <br />
<br />
Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein&nbsp;<tt>&</tt> voranstellt. Die Umkehrung davon &ndash; also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist &ndash; erledigt ein vorgestellter&nbsp;<tt>*</tt>. Der Operator &nbsp;<tt>*</tt> gibt also den ''Inhalt'' der Adresse.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int * zeiger;<br />
int zahl;<br />
<br />
zeiger = &zahl;<br />
*zeiger = 12;<br />
<br />
printf ("%d = %d", zahl, *zeiger);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der&nbsp;<tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:<br />
int * zeiger, zahl;<br />
<br />
Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator&nbsp;<tt>&</tt> von <tt>zahl</tt>:<br />
zeiger = &zahl; <br />
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>). <br />
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.<br />
<br />
==Zusammengesetzte Datentypen==<br />
===Arrays===<br />
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays &ndash; teilweise auch als ''Felder'' bezeichnet &ndash; zu verwenden.<br />
<br />
In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> arbeiten!<br />
<br />
'''Syntax:''' Datentyp Variablenname[Anzahl]<br />
<br />
Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für 3 Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes. <br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int i;<br />
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */<br />
<br />
for (i=0; i<10; i++)<br />
{<br />
printf ("Bitte Zahl %d eingeben: ", i);<br />
scanf ("%d", & zahlen[i]);<br />
printf ("\n");<br />
}<br />
printf ("Super!\n");<br />
<br />
for (i=0; i<10; i++) <br />
printf ("Zahl %d ist: %d\n", i, zahlen[i]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen:''' <br />
Zuerst wird ein 10 int-Variablen großes Array angelegt. <br />
In dieses wird nun der Reihe nach 10 Zahlen eingelesen. <br />
Anschließend werden alle 10 Zahlen ausgegeben. <br />
<br />
{{FarbigerRahmen|<br />
'''Merke:'''<br />
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!<br />
}}<br />
<br />
===Strings (Zeichenketten)===<br />
Ein String ist nicht sanderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.<br />
<br />
Die Definition eines Strings erfolgt also genauso wie bei Arrays:<br />
char string[21];<br />
<br />
Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert". <br />
<br />
Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.<br />
<br />
===Mehrdimensionale Arrays===<br />
Manchmal benötigen mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.<br />
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:<br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int x,y;<br />
int feld[3][5];<br />
<br />
for (x=0; x<3; x++) <br />
{<br />
for (y=0; y<5; y++)<br />
{<br />
printf ("Feldwert x: %d, y: %d ", x, y);<br />
scanf ("%d", & feld[x][y]);<br />
printf ("\n");<br />
}<br />
}<br />
<br />
for(x=0; x<3; x++) <br />
for (y=0; y<5; y++) <br />
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Erklärung:''' <br />
<br />
Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt. <br />
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>. <br />
Zum Schluß werden alle Werte noch einmal ausgegeben.<br />
<br />
===Strukturen===<br />
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden: <br />
<br />
<pre><br />
struct Person <br />
{<br />
int id;<br />
char vname[20], nname[20];<br />
char telnr[15];<br />
int alter;<br />
};<br />
</pre><br />
<br />
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein. <br />
Dann werden in dieser Struktur vier Komponenten angelege: drei Strings und zwei <tt>int</tt>. <br />
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach <br />
struct Person Variablenname;<br />
an. <br />
<br />
Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:<br />
<pre><br />
struct Person hubert, klaus;<br />
<br />
hubert.alter = 32;<br />
klaus.alter = hubert.alter + 1;<br />
</pre><br />
<br />
===Unions===<br />
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.<br />
<pre><br />
union Daten <br />
{<br />
int id;<br />
<br />
struct u_double<br />
{<br />
int id;<br />
double wert;<br />
};<br />
<br />
struct Person u_person;<br />
<br />
struct u_pointer<br />
{<br />
int id;<br />
union Daten * p1;<br />
union Daten * p2;<br />
};<br />
};<br />
<br />
union Daten data;<br />
</pre><br />
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_double</tt>, <tt>u_person</tt> und <tt>u_pointer</tt>. Die Große der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden.<br />
<br />
Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:<br />
<pre><br />
typedef union<br />
{<br />
unsigned long as_long;<br />
unsignen chat as_byte[4];<br />
} data32_t;<br />
</pre><br />
Dies überlagert einen <tt>unsigned long</tt> &ndash; also eine 32-Bit-Zahl &ndash; mit vier Bytes.<br />
<pre><br />
data32_t wert;<br />
<br />
wert.as_long = 0x12345678;<br />
wert.as_byte[0] = 0xab;<br />
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */<br />
</pre><br />
<br />
=Variablen=<br />
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.<br />
<br />
==Variablennamen==<br />
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.<br />
<br />
Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.<br />
==Anlegen von Variablen==<br />
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung! <br />
<pre><br />
int Zahl1, Zahl2;<br />
char Zeichen;<br />
<br />
int main (void)<br />
{<br />
float gleitZahl;<br />
/* Anweisungen */<br />
<br />
return 0;<br />
}<br />
</pre><br />
;Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].<br />
<br />
==Zuweisungen==<br />
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]]. <br />
<pre><br />
int main (void)<br />
{<br />
int zahl1, zahl2 = 12;<br />
char zeichen1 = 'A';<br />
<br />
zahl1 = 52;<br />
zeichen1 = zeichen1 + 1; <br />
<br />
return 0;<br />
}<br />
</pre><br />
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>). <br />
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen. <br />
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.<br />
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.<br />
<br />
==Zuweisungen bei float==<br />
Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt: <br />
floatVariable = 3.14;<br />
Zusätzlich kann eine Zehnerpotenz angegeben werden:<br />
floatVariable2 = -1.234E-6;<br />
Dadurch wird der erst Wert mit 10<sup><tt>-</tt>6</sup> multipliziert, der Wert der Variablen ist also <br />
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.<br />
<br />
==Zuweisungen bei logischen Variablen==<br />
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr". <br />
intVariable = !0; /* entspricht "wahr" */<br />
intVariable = 0; /* entspricht "unwahr" */<br />
<br />
==Vergleich von Variablen==<br />
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln: <br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|}<br />
</center><br />
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl. <br />
intVariable = zahl1 <= zahl2;<br />
das komplette Beispiel zeigt es deutlicher:<br />
<pre><br />
int i;<br />
int z1, z2;<br />
<br />
z1 = 5;<br />
z2 = 100;<br />
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */<br />
<br />
printf ("Ergebnis: %d\n", i);<br />
</pre><br />
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").<br />
<br />
==Konstanten==<br />
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:<br />
const ''datentyp'' name = value; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. <br />
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.<br />
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit<br />
* ((float*) &PI) = 2;<br />
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.<br />
<br />
Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist<br />
void foo (const char * str, ...);<br />
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.<br />
<br />
Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:<br />
void foo (char * const str, ...);<br />
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>. Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim&nbsp;<tt>*</tt> auf: Steht das <tt>const</tt> links vom&nbsp;<tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides &ndash; also den Zeiger und sein Ziel &ndash; als konstant zu markieren.<br />
<br />
==Gültigkeitsbereich==<br />
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln: <br />
<br />
;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.<br />
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.<br />
<br />
==Speicherklassen==<br />
Jede Variable in C gehört zu einer bestimmten Speicherklasse<br />
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.<br />
;<tt>extern</tt>: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].<br />
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.<br />
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable &ndash; falls möglich &ndash; als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!<br />
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.<br />
<br />
=Ausdrücke=<br />
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.<br />
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.<br />
<br />
Einfache Beispiele für Ausdrücke sind also z.B.:<br />
1<br />
a<br />
'a'<br />
1 + a<br />
a == 1<br />
<br />
Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.<br />
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,<br />
und wei man damit neue Ausdrücke aufbauen kann.<br />
<br />
==Lvalues==<br />
<br />
Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.<br />
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.<br />
<br />
Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:<br />
a = 1;<br />
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie<br />
a+1 = 2;<br />
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":<br />
"ungültiger Wert in Zuweisung"<br />
<br />
Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante&nbsp;4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung&nbsp;<tt>*</tt> wird an die Adresse&nbsp;4 im Speicher eine&nbsp;3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.<br />
* ((unsigned int *) 4) = 3;<br />
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue<br />
<br />
==Logische (boolsche) Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a &amp;&amp; b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr<br />
|-<br />
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr<br />
|-<br />
|<tt>a == b</tt> || gleich<br />
|-<br />
|<tt>a != b</tt> || ungleich<br />
|-<br />
|<tt>a <= b</tt> || kleiner oder gleich<br />
|-<br />
|<tt>a < b</tt> || kleiner als<br />
|-<br />
|<tt>a >= b</tt> || glösser oder gleich<br />
|-<br />
|<tt>a > b</tt> || grösser als<br />
|-<br />
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa<br />
|}<br />
</center><br />
<br />
Eine interessante Eigenheit der Operatoren <tt>&amp;&amp;</tt> und <tt>||</tt> ist, dass<br />
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden<br />
dabei immer von links nach rechts ausgewertet.<br />
<br />
Beispiel:<br />
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */<br />
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */<br />
<br />
<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,<br />
die eine aufwändige Operation durchführt.<br />
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder<br />
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.<br />
<br />
Wo ist also der Unterschied?<br><br />
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,<br />
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.<br />
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte<br />
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.<br />
<br />
==Arithmetische Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a + b</tt> || Summe (Addition)<br />
|-<br />
|<tt>a - b</tt> || Differenz (Subtraktion)<br />
|-<br />
|<tt>a * b</tt> || Produkt (Multiplikation)<br />
|-<br />
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)<br />
|-<br />
|<tt>a % b</tt> || Rest bei Division (Modulo)<br />
|-<br />
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)<br />
|}<br />
</center><br />
==Bit-Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a & b</tt> || bitweise und (and)<br />
|-<br />
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)<br />
|-<br />
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)<br />
|-<br />
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)<br />
|}<br />
</center><br />
==Index-Operator bei Arrays==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a<br />
|}<br />
</center><br />
<br />
Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:<br />
<br />
# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein<br />
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)<br />
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!<br />
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung<br />
<br />
==Komponenten-Auswahl bei Structs und Unions==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a<br />
|}<br />
</center><br />
<br />
==Adress-Operator und Dereferenzierung==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>&amp;a</tt> || Speicheradresse der Variablen <tt>a</tt><br />
|-<br />
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht<br />
|-<br />
||<tt>a-&gt;b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht<br />
|}<br />
</center><br />
<br />
Der Adressoperator & kann auf Variablen angewendet werden und<br />
gibt die Startadresse der Variablen im Speicher zurück.<br />
<br />
Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält<br />
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der<br />
an dieser Adresse steht, wird der Operator * vorangestellt.<br />
<br />
Beispiel:<br />
<pre><br />
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */<br />
<br />
/* z ist ein Zeiger auf eine Integervariable und enthält somit<br />
die Speicheradresse einer Integervariablen<br />
*/<br />
int *z; <br />
<br />
/* Verwendung des Adressoperators... */<br />
z = &x; /* weise z die Speicheradresse von x zu */<br />
<br />
/* Verwendung der Dereferenzierung */<br />
/* erhöhe den Wert, der bei Adresse z steht um eins */<br />
*z = *z + 1;<br />
<br />
/* da z auf x zeigt, hat auch x jetzt den Wert 6 */<br />
</pre><br />
<br />
Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff<br />
auf ein Element eine abkürzende Schreibweise möglich:<br />
<br />
Statt <br />
(*strukturZeiger).element<br />
kann geschrieben werden<br />
strukturZeiger->element<br />
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch<br />
auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu<br />
einer Änderung '''irgendeiner''' Speicherstelle:<br />
<br />
<pre><br />
int *z; /* z ist ein Zeiger auf einen Integer */<br />
<br />
/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.<br />
z enthält irgendeine(!) Adresse<br />
*/<br />
<br />
/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */<br />
*z = *z + 1;<br />
</pre><br />
<br />
Viele C-Compiler (z.B. gcc) erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!<br />
}}<br />
<br />
==Cast-Operator==<br />
<br />
Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.<br />
<br />
Um zum Beispiel aus einem Float ein Integer zu machen:<br />
var = (int) 5.60;<br />
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.<br />
<br />
Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:<br />
int * addr;<br />
addr = (int*) 0x1234;<br />
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder<br />
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in<br />
eine Zahl oder umgekehrt zu wandeln:<br />
<br />
<pre><br />
#include <stdio.h><br />
int main(int argc, char ** argv)<br />
{<br />
char text[] = "5.6";<br />
int zahl = (int)text;<br />
<br />
printf("%d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator<br />
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.<br />
}}<br />
<br />
==Komma Operator==<br />
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.<br />
Die Auswertung erfolgt von links nach rechts.<br />
<br />
Solche Konstrukte sieht man manchmal in Abfragen wie<br />
FILE *file;<br />
if (file = fopen ("foo.exe", "r"), file != NULL)<br />
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,<br />
wenn <tt>file</tt> nicht der Nullpointer ist.<br />
<br />
==Zuweisungen und Operatoren mit Nebeneffekt==<br />
===Bedingte Zuweisung===<br />
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;<br />
<br />
<!--<br />
Kein ANSI-C<br />
--[[Benutzer:SprinterSB|SprinterSB]] 17:15, 29. Jun 2006 (CEST)<br />
==Blöcke==<br />
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.<br />
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks. <br />
Der Block muss un runden Klammern stehen:<br />
int sum;<br />
sum = ({<br />
int i, s = 0;<br />
for (i=1; i<= 100; i++)<br />
s += i;<br />
s;<br />
});<br />
<br />
Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc, <br />
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer<br />
Instruktion nicht machbar wäre:<br />
<pre><br />
#define PSTR(s) \<br />
({ \ <br />
static char __c[] PROGMEM = (s); \<br />
__c; \<br />
})<br />
</pre><br />
--><br />
<br />
==Reihenfolge der Auswertung==<br />
<br />
=Kontrollanweisungen=<br />
<br />
==Boolsche Logik==<br />
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird). <br />
<br />
b1= b2 && b3;<br />
<br />
<br />
Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).<br />
<br />
<br />
b1= b2 || b3;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.<br />
<br />
<br />
b1= !b2;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".<br />
<br />
==<tt>if</tt>-Anweisung==<br />
Syntax: IF (Bedingung) Anweisung;<br />
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:<br />
<br />
[[bild:ifthenelse.png]]<br />
<br />
Und in C schreibt man:<br />
<pre><br />
if (Bedingung) /* WENN */<br />
{ /* DANN */<br />
Anweisung1;<br />
Anweisung2;<br />
...<br />
}<br />
else<br />
{ /* SONST */<br />
Anweisung3;<br />
Anweisung4;<br />
...<br />
}<br />
</pre><br />
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt. <br />
<br />
Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki><br />
<br />
<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki><br />
<br />
<br />
Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.<br />
}}<br />
<br />
==<tt>switch</tt>-Anweisung==<br />
Syntax: <br />
<pre><br />
switch(ausdruck) {<br />
case wert1:<br />
Anweisungen1...<br />
case wert2:<br />
Anweisungen2...<br />
case wert3:<br />
Anweisungen3...<br />
...<br />
default:<br />
Anweisungen4...<br />
}<br />
</pre><br />
<br />
Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter<br />
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der<br />
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt><br />
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.<br />
<br />
<b>Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines<br />
<tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!</b><br />
<br />
Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.<br />
Der <tt>default</tt>-Abschnitt ist optional, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,<br />
wenn er verwendet wird.<br />
<br />
<br />
==Schleifen==<br />
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.<br> <br />
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird. <br />
<br />
===<tt>while</tt>-Schleife===<br />
'''Syntax:''' while (Bedingung) { Anweisung; }<br />
<br />
Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block! <br />
<br />
<pre><br />
Zahl1=0;<br />
while (Zahl1<3)<br />
{<br />
Zahl1=Zahl1+1;<br />
Zahl2=Zahl2*2;<br />
}<br />
</pre><br />
<br />
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.<br />
===<tt>do</tt>-<tt>while</tt>-Schleife===<br />
'''Syntax:''' do { Anweisung; }while (Bedingung);<br />
<br />
Die DO WHILE-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird <br />
<br />
<pre><br />
int i=2;<br />
do <br />
{<br />
i = i*i; /* i quadrieren */<br />
printf ("i = %d\n", i);<br />
}<br />
while (i < 20);<br />
</pre><br />
<br />
Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.<br />
<br />
===<tt>for</tt>-Schleife===<br />
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }<br />
<br />
Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.<br />
<br />
Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.<br />
<br />
Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet. <br />
<br />
<pre><br />
int lauf;<br />
int summe = 0;<br />
<br />
for (lauf = 1; lauf <= 10; lauf = lauf+2 ) <br />
{<br />
summe = summe + lauf;<br />
}<br />
</pre><br />
Das Äquivalent als <tt>while</tt>-Schleife:<br />
<pre><br />
int lauf = 1; /* Anfangswerte */<br />
int summe = 0;<br />
<br />
while (lauf <= 10) /* Bedingung */<br />
{<br />
summe = summe + lauf;<br />
lauf += 2; /* Inkrement */<br />
}<br />
</pre><br />
<br />
<br />
In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.<br />
<br />
'''Erklärung:''' <br />
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. <br />
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. <br />
<tt>lauf = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um&nbsp;2 erhöht wird.<br />
<br />
=Ein- und Ausgabe=<br />
<br />
==Bildschirm-Ausgabe==<br />
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.<br />
<br />
Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, </tt>char</tt>, <tt>double</tt>...) sein! <br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int zahl1 = 12;<br />
char zeichen1 = 'A';<br />
<br />
printf ("Das ist Text, und er wird als solcher ausgegeben. \n");<br />
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile. <br />
<br />
Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus. <br />
<br />
In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert. <br />
<br />
Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen! <br />
<br />
==Tastatur-Eingabe==<br />
<br />
Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.<br />
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>: <br />
<br />
<pre><br />
int zahl1;<br />
char zeichen1;<br />
<br />
printf ("Bitte geben Sie eine Zahl ein: ");<br />
scanf ("%d", &zahl1);<br />
printf ("Geben Sie einen Zeichen ein: ");<br />
scanf ("%c", &zeichen1);<br />
</pre><br />
<br />
Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.<br />
<br />
Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!<br />
<br />
Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference"). <br />
<br />
<br />
=Allgemeines zu Unterprogrammen=<br />
Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen.<br />
Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen: <br />
<br />
==Funktionen==<br />
'''Syntax:''' Rückgabe-Typ Name(Parameterliste);<br />
<br />
Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln: <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int hoch2 (int param1)<br />
{<br />
int zahl;<br />
zahl = param1 * param1;<br />
return zahl;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl1, ergebnis;<br />
<br />
printf ("Bitte Zahl eingeben: ");<br />
scanf ("%d",&zahl1);<br />
<br />
ergebnis = hoch2 (zahl1);<br />
<br />
printf ("%d hoch 2 = %d\n",zahl1, ergebnis);<br />
printf ("5 hoch 2 = %d\n", hoch2(5));<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. <br />
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. <br />
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.<br />
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. <br />
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert. <br />
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an<br />
variable = Funktion (Parameter);<br />
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile). <br />
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.<br />
<br />
==Prozedur==<br />
'''Syntax:''' <tt>void Name (Parameterliste)</tt><br />
<br />
Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp <tt>void</tt>, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede: <br />
<br />
Als Rückgabe-Datentyp wird <tt>void</tt> angegeben. <br />
Einer Variablen kann daher nicht der Rückgabewert einer <tt>void</tt>-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int param1)<br />
{<br />
printf ("Der Wert der Variablen ist: %d\n", param1);<br />
}<br />
<br />
int main(void)<br />
{<br />
int zahl1 = 4;<br />
<br />
ausgeben (23);<br />
ausgeben (zahl1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Durch den Befehl "<tt>ausgeben(23)</tt>" wird die Prozedur "<tt>ausgeben</tt>" mit dem Parameter <tt>23</tt> aufgerufen. <tt>param1</tt> hat also den Wert <tt>23</tt>. Die einzige Anweisung innerhalb der Prozedur ist <tt>printf</tt>, was nun ausgeführt wird. <br />
Der zweite Aufruf von <tt>ausgeben</tt> erfolgt mit dem Parameter <tt>zahl1</tt>, also wird <tt>param1</tt> der Wert 4 zugewiesen. Dieser wird nun wieder mittels <tt>printf</tt> ausgeben. <br />
<br />
Unterprogramme ohne Parameter<br />
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur <tt>void</tt> stehen. Das <tt>void</tt> bedeutet "die Funktion erhält keine Parameter". "<tt>void main (void)</tt>" bedeutet also: "Erstelle ein Unterprogramm Namens <tt>main</tt>, das keinen Rückgabewert und keine Parameter hat".<br />
<br />
{{FarbigerRahmen |<br />
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:<br />
foo();<br />
}}<br />
<br />
==Prototypen==<br />
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?<br />
Um dies zu erreichen, gibt es zwei Möglichkeiten: <br />
<br />
Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! <br />
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. <br />
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt&nbsp;<tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). <br />
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int zahl); /* Der Prototyp */<br />
<br />
int main (void)<br />
{<br />
ausgeben (12);<br />
<br />
return 0;<br />
}<br />
<br />
void ausgeben (int zahl) /* Die eigentliche Prozedur */<br />
{<br />
printf ("Ausgabe: %d\n", zahl);<br />
}<br />
</pre><br />
<br />
==Parameterübergabe==<br />
<br />
Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.<br />
Das hat folgende Auswirkungen:<br />
<br />
# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!<br />
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger | Zeiger]] übergeben werden.<br />
# Werden [[#Strukturen | Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.<br />
<br />
<br />
Beispiele:<br />
<pre><br />
void erhoehe (int x)<br />
{<br />
x = x + 1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int a = 0;<br />
erhoehe(a);<br />
/* a ist immer noch 0 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.<br />
<br />
<pre><br />
void erhoehe (int *x)<br />
{<br />
/* erhöhe den Wert an der Adresse x um eins */<br />
*x = *x + 1;<br />
}<br />
<br />
int main(void)<br />
{<br />
int a = 0;<br />
erhoehe (&a);<br />
/* a ist jetzt 1 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&amp;</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die<br />
Adresse des Originals <tt>a</tt> und kann direkt mit dem Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.<br />
<br />
<br />
'''Besonderheit bei Feldern'''<br />
<br />
Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines<br />
Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.<br />
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf<br />
den Originaldaten arbeiten und diese verändern.<br />
<br />
Beispiel:<br />
<pre><br />
void erhoehe (int x[])<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
<br />
Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:<br />
<br />
<pre><br />
/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */<br />
void erhoehe (int *x)<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
}<br />
</pre><br />
<br />
{{FarbigerRahmen |<br />
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.<br />
}}<br />
<br />
=Standard-Funktionen=<br />
<br />
==strcpy==<br />
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren! <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri1[21], eingabe[21];<br />
<br />
strcpy (stri1, "hallo");<br />
<br />
printf ("Der 1. String: %s\n", stri1);<br />
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");<br />
scanf ("%s", eingabe);<br />
strcpy (stri1, eingabe);<br />
printf ("\n%s = %s", stri1, eingabe);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Hinweis:''' <br />
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&amp;</tt> bei <tt>scanf</tt> angeben!<br />
<br />
'''Erklärung:''' <br />
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen. <br />
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. <br />
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings. <br />
Sie werden gebeten, eine String einzugeben. <br />
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert. <br />
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.<br />
<br />
==strlen==<br />
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern. <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri[21];<br />
<br />
strcpy (stri, "hallo");<br />
printf ("Der String ist %d Zeichen lang", strlen (stri));<br />
}<br />
</pre><br />
<br />
Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc. <br />
<br />
<br />
<br />
===Zeiger als Parameter===<br />
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.<br />
Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable"). <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void erhoehe (int *zeiger)<br />
{<br />
*zeiger = *zeiger+1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl;<br />
<br />
printf ("Zahl eingeben: ");<br />
scanf ("%d", &zahl);<br />
erhoehe (&zahl);<br />
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
==Parameter von <tt>main</tt>==<br />
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen. <br />
<pre><br />
int main (int argc, char *argv[], char* environ[])<br />
</pre><br />
<br />
Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge&nbsp;0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.<br />
<pre><br />
#include <stdio.h><br />
#include <stdlib.h><br />
<br />
int main (int argc, char *argv[], char * environ[])<br />
{<br />
int i;<br />
<br />
printf ("Es wurden %d Parameter angegeben", argc);<br />
<br />
for (i=0; i < argc; i++) <br />
printf ("Parameter %d: %s\n", i, argv[i]);<br />
<br />
for (i = 0; environ[i] != NULL; ++i) <br />
printf ("environ[%d] = %s\n", i, environ[i]);<br />
}<br />
</pre><br />
<br />
;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement &ndash; wie in C üblich &ndash; das Element <tt><tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen! <br />
<br />
=Liste der Schlüsselworte=<br />
<br />
* [[#Speicherklassen|auto]]<br />
* break<br />
* [[#Elementare Datentypen|double]]<br />
* [[#Elementare Datentypen|char]]<br />
* case<br />
* [[#Konstanten|const]]<br />
* continue<br />
* default<br />
* do<br />
* else<br />
* enum<br />
* [[#Speicherklassen|extern]]<br />
* [[#Elementare Datentypen|float]]<br />
* for<br />
* goto<br />
* if<br />
* [[##Elementare Datentypen|int]]<br />
* [[#Elementare Datentypen|long]]<br />
* return<br />
* [[#Speicherklassen|register]]<br />
* [[#Elementare Datentypen|short]]<br />
* signed<br />
* sizeof<br />
* [[#Speicherklassen|static]]<br />
* [[#Strukturen|struct]]<br />
* switch<br />
* typedef<br />
* [[#Unions|union]]<br />
* unsigned<br />
* [[#Elementare Datentypen|void]]<br />
* volatile<br />
* while<br />
<br />
Baustelle<br />
<br />
=Liste der Operatoren=<br />
<br />
Baustelle<br />
<br />
<font color="blue"><></font><br />
<br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung || Nebeneffekte<br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> == <font color="blue"><Ausdruck></font></tt> || ist gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> != <font color="blue"><Ausdruck></font></tt> || ist nicht gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt; <font color="blue"><Ausdruck></font></tt> || ist kleiner <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt;= <font color="blue"><Ausdruck></font></tt> || ist kleiner oder gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt; <font color="blue"><Ausdruck></font></tt> || ist größer <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt;= <font color="blue"><Ausdruck></font></tt> || ist größer oder gleich <br />
|-<br />
| <tt>&amp; <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> = <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> += <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> -= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> *= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> /= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ^= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> &= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> |= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>++ <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ++</tt> || <br />
|-<br />
| <tt>-- <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> --</tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> && <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> <nowiki>||</nowiki> <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>~ <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>! <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Type></font>) <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> + <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> - <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> * <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> / <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> % <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> %= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Bedingung></font>) ? <font color="blue"><Ausdruck></font> : <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Struct></font>.<font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Zeiger-auf-Struct></font>-><font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|}<br />
<br />
<br />
'''Autoren'''<br />
* Plasma<br />
* Bernd<br />
* [[Benutzer:SprinterSB|SprinterSB]]<br />
<br />
'''Quellen:'''<br />
* Kernighan und Ritchie - Buch<br />
* Christian Wirth , C Tutorial<br />
* Prof. Dr. J. Dankert Ausführungen<br />
<br />
=Siehe auch=<br />
* [[avr-gcc]]<br />
* [[Compiler]]<br />
* [[WinAVR]]<br />
* [[Fallstricke bei der C-Programmierung]]<br />
<br />
=Weblinks=<br />
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]<br />
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]<br />
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]<br />
<br />
[[Kategorie:Quellcode C|!]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=C-Tutorial&diff=8122C-Tutorial2006-07-05T11:10:20Z<p>Roberto: /* int, char, short, long (ganze Zahlen) */</p>
<hr />
<div>Ein kurzer Einblick in die Programmiersprache C<br />
=Allgemeines=<br />
C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.<br />
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.<br />
<br />
C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu lediglich einen anderen Compiler, und Inline-Assembler Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden. <br />
<br />
==Geschichte==<br />
;1971: C wird entwickelt<br />
;1978: Kernighan und Ritchie definieren die Sprache.<br />
;1983: ANSI und ISO standardisieren C.<br />
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.<br />
<br />
=Aufbau eines C-Programmes=<br />
<!-- <br />
<br />
C-Programme haben keinen fixen Aufbau wie z.B. Pascal. Es gibt zwar gewisse Regeln, aber sonst sind dem Programmierer alle Freiheiten überlassen. Der folgende "Beispiel-Aufbau" ist daher nicht zwingend und kann durchaus verändert werden.<br />
<br />
Natürlich haben C-Programme einen fixen Aufbau! Ebenso wie Pascal-Programme auch unterliegen sie einer strikten Grammatik! <br />
Auskommentiert --[[Benutzer:SprinterSB|SprinterSB]] 10:23, 17. Feb 2006 (CET)<br />
--><br />
Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau. <br />
<pre><br />
#include <stdio.h><br />
<br />
int Zahl1;<br />
char Zeichen1;<br />
<br />
int main (void)<br />
{<br />
int zahl2;<br />
<br />
/* Anweisungen */<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Beschreibung (die Erklärungen folgen): <br />
<br />
;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.<br />
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.<br />
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert. <br />
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.<br />
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.<br />
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert. <br />
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.<br />
;return 0;: Gibt den Wert&nbsp;0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.<br />
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.<br />
<br />
=Das Hauptprogramm main=<br />
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm. <br />
<br />
Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer &ndash; üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt. <br />
<br />
Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!<br />
<pre><br />
/* <br />
* void Definition von main ist nur beim Controller üblich<br />
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main<br />
* kein Fehler/Warnung erzeugt wird. <br />
*/<br />
void main (void)<br />
{<br />
...<br />
}<br />
</pre><br />
<br />
=Blöcke=<br />
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung.<br />
Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende": <br />
<br />
<pre><br />
int main (void)<br />
{ /* der Block "main" beginnt */<br />
int zahl;<br />
<br />
{ /* ein Block beginnt */<br />
/* hier können Deklarationen und Anweisungen stehen */<br />
} /* der Block endet */<br />
<br />
return 0;<br />
} /* "main" endet */<br />
</pre><br />
<br />
'''Bemerkung:''' <br />
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!<br />
<br />
=Datentypen=<br />
==Elementare Datentypen==<br />
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.<br />
<br />
;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!<br />
<br />
===int, char, short, long (ganze Zahlen)===<br />
In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen. <br />
<br />
Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann reicht der Wertebereich von <tt>-2<sup>''b''-1</sup></tt> bis zu <tt>2<sup>''b''-1</sup>-1</tt>.<br />
<br />
Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2<sup>''b''</sup>-1</tt>, wenn der Typ ''b'' Bits breit ist.<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs<br />
|- <br />
| 8 || <tt>char</tt> <br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -128<br />0<br />
| align="right" | 127<br />255<br />
|- <br />
| 16 || <tt>short</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -32.768<br />0<br />
| align="right" | 32.767<br />65.535<br />
|- <br />
| 32 || <tt>long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -2.147.483.648<br />0<br />
| align="right" | 2.147.483.647<br />4.294.967.295<br />
|- <br />
| 64 || <tt>long long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -9.223.372.036.854.775.808<br />0<br />
| align="right" | 9.223.372.036.854.775.807<br />18.446.744.073.709.551.615<br />
|-<br />
|8, 16, 32, 64<br/><br />
| <tt>int</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
|plattform-/compilerabhängig<br />
|plattform-/compilerabhängig<br />
|}<br />
</center><br />
<br />
==== Boolean (Logische Variablen)====<br />
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.<br />
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.<br />
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert&nbsp;1 haben muß. Sie muß lediglich ungleich&nbsp;0 sein!<br />
<br />
====char (Zeichen)====<br />
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen. <br />
<br />
Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!<br />
<br />
===float, double (Gleitkommazahlen)===<br />
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. <br />
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.<br />
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.<br />
<br />
===void===<br />
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.<br />
<br />
==Zeiger==<br />
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''. <br />
<br />
Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein&nbsp;<tt>&</tt> voranstellt. Die Umkehrung davon &ndash; also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist &ndash; erledigt ein vorgestellter&nbsp;<tt>*</tt>. Der Operator &nbsp;<tt>*</tt> gibt also den ''Inhalt'' der Adresse.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int * zeiger;<br />
int zahl;<br />
<br />
zeiger = &zahl;<br />
*zeiger = 12;<br />
<br />
printf ("%d = %d", zahl, *zeiger);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der&nbsp;<tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:<br />
int * zeiger, zahl;<br />
<br />
Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator&nbsp;<tt>&</tt> von <tt>zahl</tt>:<br />
zeiger = &zahl; <br />
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>). <br />
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.<br />
<br />
==Zusammengesetzte Datentypen==<br />
===Arrays===<br />
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays &ndash; teilweise auch als ''Felder'' bezeichnet &ndash; zu verwenden.<br />
<br />
In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis </tt>Zahl_99</tt> arbeiten!<br />
<br />
'''Syntax:''' Datentyp Variablenname[Anzahl]<br />
<br />
Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für 3 Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes. <br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int i;<br />
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */<br />
<br />
for (i=0; i<10; i++)<br />
{<br />
printf ("Bitte Zahl %d eingeben: ", i);<br />
scanf ("%d", & zahlen[i]);<br />
printf ("\n");<br />
}<br />
printf ("Super!\n");<br />
<br />
for (i=0; i<10; i++) <br />
printf ("Zahl %d ist: %d\n", i, zahlen[i]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen:''' <br />
Zuerst wird ein 10 int-Variablen großes Array angelegt. <br />
In dieses wird nun der Reihe nach 10 Zahlen eingelesen. <br />
Anschließend werden alle 10 Zahlen ausgegeben. <br />
<br />
{{FarbigerRahmen|<br />
'''Merke:'''<br />
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!<br />
}}<br />
<br />
===Strings (Zeichenketten)===<br />
Ein String ist nicht sanderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.<br />
<br />
Die Definition eines Strings erfolgt also genauso wie bei Arrays:<br />
char string[21];<br />
<br />
Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert". <br />
<br />
Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.<br />
<br />
===Mehrdimensionale Arrays===<br />
Manchmal benötigen mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.<br />
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:<br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int x,y;<br />
int feld[3][5];<br />
<br />
for (x=0; x<3; x++) <br />
{<br />
for (y=0; y<5; y++)<br />
{<br />
printf ("Feldwert x: %d, y: %d ", x, y);<br />
scanf ("%d", & feld[x][y]);<br />
printf ("\n");<br />
}<br />
}<br />
<br />
for(x=0; x<3; x++) <br />
for (y=0; y<5; y++) <br />
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Erklärung:''' <br />
<br />
Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt. <br />
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>. <br />
Zum Schluß werden alle Werte noch einmal ausgegeben.<br />
<br />
===Strukturen===<br />
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden: <br />
<br />
<pre><br />
struct Person <br />
{<br />
int id;<br />
char vname[20], nname[20];<br />
char telnr[15];<br />
int alter;<br />
};<br />
</pre><br />
<br />
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein. <br />
Dann werden in dieser Struktur vier Komponenten angelege: drei Strings und zwei <tt>int</tt>. <br />
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach <br />
struct Person Variablenname;<br />
an. <br />
<br />
Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:<br />
<pre><br />
struct Person hubert, klaus;<br />
<br />
hubert.alter = 32;<br />
klaus.alter = hubert.alter + 1;<br />
</pre><br />
<br />
===Unions===<br />
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.<br />
<pre><br />
union Daten <br />
{<br />
int id;<br />
<br />
struct u_double<br />
{<br />
int id;<br />
double wert;<br />
};<br />
<br />
struct Person u_person;<br />
<br />
struct u_pointer<br />
{<br />
int id;<br />
union Daten * p1;<br />
union Daten * p2;<br />
};<br />
};<br />
<br />
union Daten data;<br />
</pre><br />
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_double</tt>, <tt>u_person</tt> und <tt>u_pointer</tt>. Die Große der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden.<br />
<br />
Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:<br />
<pre><br />
typedef union<br />
{<br />
unsigned long as_long;<br />
unsignen chat as_byte[4];<br />
} data32_t;<br />
</pre><br />
Dies überlagert einen <tt>unsigned long</tt> &ndash; also eine 32-Bit-Zahl &ndash; mit vier Bytes.<br />
<pre><br />
data32_t wert;<br />
<br />
wert.as_long = 0x12345678;<br />
wert.as_byte[0] = 0xab;<br />
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */<br />
</pre><br />
<br />
=Variablen=<br />
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.<br />
<br />
==Variablennamen==<br />
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.<br />
<br />
Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.<br />
==Anlegen von Variablen==<br />
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung! <br />
<pre><br />
int Zahl1, Zahl2;<br />
char Zeichen;<br />
<br />
int main (void)<br />
{<br />
float gleitZahl;<br />
/* Anweisungen */<br />
<br />
return 0;<br />
}<br />
</pre><br />
;Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].<br />
<br />
==Zuweisungen==<br />
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]]. <br />
<pre><br />
int main (void)<br />
{<br />
int zahl1, zahl2 = 12;<br />
char zeichen1 = 'A';<br />
<br />
zahl1 = 52;<br />
zeichen1 = zeichen1 + 1; <br />
<br />
return 0;<br />
}<br />
</pre><br />
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>). <br />
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen. <br />
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.<br />
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.<br />
<br />
==Zuweisungen bei float==<br />
Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt: <br />
floatVariable = 3.14;<br />
Zusätzlich kann eine Zehnerpotenz angegeben werden:<br />
floatVariable2 = -1.234E-6;<br />
Dadurch wird der erst Wert mit 10<sup><tt>-</tt>6</sup> multipliziert, der Wert der Variablen ist also <br />
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.<br />
<br />
==Zuweisungen bei logischen Variablen==<br />
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr". <br />
intVariable = !0; /* entspricht "wahr" */<br />
intVariable = 0; /* entspricht "unwahr" */<br />
<br />
==Vergleich von Variablen==<br />
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln: <br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|}<br />
</center><br />
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl. <br />
intVariable = zahl1 <= zahl2;<br />
das komplette Beispiel zeigt es deutlicher:<br />
<pre><br />
int i;<br />
int z1, z2;<br />
<br />
z1 = 5;<br />
z2 = 100;<br />
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */<br />
<br />
printf ("Ergebnis: %d\n", i);<br />
</pre><br />
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").<br />
<br />
==Konstanten==<br />
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:<br />
const ''datentyp'' name = value; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. <br />
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.<br />
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit<br />
* ((float*) &PI) = 2;<br />
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.<br />
<br />
Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist<br />
void foo (const char * str, ...);<br />
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.<br />
<br />
Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:<br />
void foo (char * const str, ...);<br />
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>. Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim&nbsp;<tt>*</tt> auf: Steht das <tt>const</tt> links vom&nbsp;<tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides &ndash; also den Zeiger und sein Ziel &ndash; als konstant zu markieren.<br />
<br />
==Gültigkeitsbereich==<br />
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln: <br />
<br />
;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.<br />
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.<br />
<br />
==Speicherklassen==<br />
Jede Variable in C gehört zu einer bestimmten Speicherklasse<br />
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.<br />
;<tt>extern</tt>: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].<br />
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.<br />
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable &ndash; falls möglich &ndash; als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!<br />
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.<br />
<br />
=Ausdrücke=<br />
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.<br />
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.<br />
<br />
Einfache Beispiele für Ausdrücke sind also z.B.:<br />
1<br />
a<br />
'a'<br />
1 + a<br />
a == 1<br />
<br />
Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.<br />
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,<br />
und wei man damit neue Ausdrücke aufbauen kann.<br />
<br />
==Lvalues==<br />
<br />
Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.<br />
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.<br />
<br />
Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:<br />
a = 1;<br />
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie<br />
a+1 = 2;<br />
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":<br />
"ungültiger Wert in Zuweisung"<br />
<br />
Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante&nbsp;4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung&nbsp;<tt>*</tt> wird an die Adresse&nbsp;4 im Speicher eine&nbsp;3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.<br />
* ((unsigned int *) 4) = 3;<br />
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue<br />
<br />
==Logische (boolsche) Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a &amp;&amp; b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr<br />
|-<br />
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr<br />
|-<br />
|<tt>a == b</tt> || gleich<br />
|-<br />
|<tt>a != b</tt> || ungleich<br />
|-<br />
|<tt>a <= b</tt> || kleiner oder gleich<br />
|-<br />
|<tt>a < b</tt> || kleiner als<br />
|-<br />
|<tt>a >= b</tt> || glösser oder gleich<br />
|-<br />
|<tt>a > b</tt> || grösser als<br />
|-<br />
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa<br />
|}<br />
</center><br />
<br />
Eine interessante Eigenheit der Operatoren <tt>&amp;&amp;</tt> und <tt>||</tt> ist, dass<br />
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden<br />
dabei immer von links nach rechts ausgewertet.<br />
<br />
Beispiel:<br />
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */<br />
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */<br />
<br />
<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,<br />
die eine aufwändige Operation durchführt.<br />
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder<br />
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.<br />
<br />
Wo ist also der Unterschied?<br><br />
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,<br />
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.<br />
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte<br />
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.<br />
<br />
==Arithmetische Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a + b</tt> || Summe (Addition)<br />
|-<br />
|<tt>a - b</tt> || Differenz (Subtraktion)<br />
|-<br />
|<tt>a * b</tt> || Produkt (Multiplikation)<br />
|-<br />
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)<br />
|-<br />
|<tt>a % b</tt> || Rest bei Division (Modulo)<br />
|-<br />
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)<br />
|}<br />
</center><br />
==Bit-Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a & b</tt> || bitweise und (and)<br />
|-<br />
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)<br />
|-<br />
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)<br />
|-<br />
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)<br />
|}<br />
</center><br />
==Index-Operator bei Arrays==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a<br />
|}<br />
</center><br />
<br />
Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:<br />
<br />
# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein<br />
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)<br />
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!<br />
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung<br />
<br />
==Komponenten-Auswahl bei Structs und Unions==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a<br />
|}<br />
</center><br />
<br />
==Adress-Operator und Dereferenzierung==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>&amp;a</tt> || Speicheradresse der Variablen <tt>a</tt><br />
|-<br />
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht<br />
|-<br />
||<tt>a-&gt;b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht<br />
|}<br />
</center><br />
<br />
Der Adressoperator & kann auf Variablen angewendet werden und<br />
gibt die Startadresse der Variablen im Speicher zurück.<br />
<br />
Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält<br />
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der<br />
an dieser Adresse steht, wird der Operator * vorangestellt.<br />
<br />
Beispiel:<br />
<pre><br />
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */<br />
<br />
/* z ist ein Zeiger auf eine Integervariable und enthält somit<br />
die Speicheradresse einer Integervariablen<br />
*/<br />
int *z; <br />
<br />
/* Verwendung des Adressoperators... */<br />
z = &x; /* weise z die Speicheradresse von x zu */<br />
<br />
/* Verwendung der Dereferenzierung */<br />
/* erhöhe den Wert, der bei Adresse z steht um eins */<br />
*z = *z + 1;<br />
<br />
/* da z auf x zeigt, hat auch x jetzt den Wert 6 */<br />
</pre><br />
<br />
Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff<br />
auf ein Element eine abkürzende Schreibweise möglich:<br />
<br />
Statt <br />
(*strukturZeiger).element<br />
kann geschrieben werden<br />
strukturZeiger->element<br />
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch<br />
auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu<br />
einer Änderung '''irgendeiner''' Speicherstelle:<br />
<br />
<pre><br />
int *z; /* z ist ein Zeiger auf einen Integer */<br />
<br />
/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.<br />
z enthält irgendeine(!) Adresse<br />
*/<br />
<br />
/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */<br />
*z = *z + 1;<br />
</pre><br />
<br />
Viele C-Compiler (z.B. gcc) erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!<br />
}}<br />
<br />
==Cast-Operator==<br />
<br />
Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.<br />
<br />
Um zum Beispiel aus einem Float ein Integer zu machen:<br />
var = (int) 5.60;<br />
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.<br />
<br />
Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:<br />
int * addr;<br />
addr = (int*) 0x1234;<br />
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder<br />
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in<br />
eine Zahl oder umgekehrt zu wandeln:<br />
<br />
<pre><br />
#include <stdio.h><br />
int main(int argc, char ** argv)<br />
{<br />
char text[] = "5.6";<br />
int zahl = (int)text;<br />
<br />
printf("%d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator<br />
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.<br />
}}<br />
<br />
==Komma Operator==<br />
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.<br />
Die Auswertung erfolgt von links nach rechts.<br />
<br />
Solche Konstrukte sieht man manchmal in Abfragen wie<br />
FILE *file;<br />
if (file = fopen ("foo.exe", "r"), file != NULL)<br />
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,<br />
wenn <tt>file</tt> nicht der Nullpointer ist.<br />
<br />
==Zuweisungen und Operatoren mit Nebeneffekt==<br />
===Bedingte Zuweisung===<br />
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;<br />
<br />
<!--<br />
Kein ANSI-C<br />
--[[Benutzer:SprinterSB|SprinterSB]] 17:15, 29. Jun 2006 (CEST)<br />
==Blöcke==<br />
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.<br />
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks. <br />
Der Block muss un runden Klammern stehen:<br />
int sum;<br />
sum = ({<br />
int i, s = 0;<br />
for (i=1; i<= 100; i++)<br />
s += i;<br />
s;<br />
});<br />
<br />
Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc, <br />
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer<br />
Instruktion nicht machbar wäre:<br />
<pre><br />
#define PSTR(s) \<br />
({ \ <br />
static char __c[] PROGMEM = (s); \<br />
__c; \<br />
})<br />
</pre><br />
--><br />
<br />
==Reihenfolge der Auswertung==<br />
<br />
=Kontrollanweisungen=<br />
<br />
==Boolsche Logik==<br />
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird). <br />
<br />
b1= b2 && b3;<br />
<br />
<br />
Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).<br />
<br />
<br />
b1= b2 || b3;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.<br />
<br />
<br />
b1= !b2;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".<br />
<br />
==<tt>if</tt>-Anweisung==<br />
Syntax: IF (Bedingung) Anweisung;<br />
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:<br />
<br />
[[bild:ifthenelse.png]]<br />
<br />
Und in C schreibt man:<br />
<pre><br />
if (Bedingung) /* WENN */<br />
{ /* DANN */<br />
Anweisung1;<br />
Anweisung2;<br />
...<br />
}<br />
else<br />
{ /* SONST */<br />
Anweisung3;<br />
Anweisung4;<br />
...<br />
}<br />
</pre><br />
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt. <br />
<br />
Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki><br />
<br />
<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki><br />
<br />
<br />
Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.<br />
}}<br />
<br />
==<tt>switch</tt>-Anweisung==<br />
Syntax: <br />
<pre><br />
switch(ausdruck) {<br />
case wert1:<br />
Anweisungen1...<br />
case wert2:<br />
Anweisungen2...<br />
case wert3:<br />
Anweisungen3...<br />
...<br />
default:<br />
Anweisungen4...<br />
}<br />
</pre><br />
<br />
Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter<br />
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der<br />
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt><br />
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.<br />
<br />
<b>Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines<br />
<tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!</b><br />
<br />
Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.<br />
Der <tt>default</tt>-Abschnitt ist optional, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,<br />
wenn er verwendet wird.<br />
<br />
<br />
==Schleifen==<br />
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.<br> <br />
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird. <br />
<br />
===<tt>while</tt>-Schleife===<br />
'''Syntax:''' while (Bedingung) { Anweisung; }<br />
<br />
Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block! <br />
<br />
<pre><br />
Zahl1=0;<br />
while (Zahl1<3)<br />
{<br />
Zahl1=Zahl1+1;<br />
Zahl2=Zahl2*2;<br />
}<br />
</pre><br />
<br />
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.<br />
===<tt>do</tt>-<tt>while</tt>-Schleife===<br />
'''Syntax:''' do { Anweisung; }while (Bedingung);<br />
<br />
Die DO WHILE-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird <br />
<br />
<pre><br />
int i=2;<br />
do <br />
{<br />
i = i*i; /* i quadrieren */<br />
printf ("i = %d\n", i);<br />
}<br />
while (i < 20);<br />
</pre><br />
<br />
Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.<br />
<br />
===<tt>for</tt>-Schleife===<br />
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }<br />
<br />
Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.<br />
<br />
Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.<br />
<br />
Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet. <br />
<br />
<pre><br />
int lauf;<br />
int summe = 0;<br />
<br />
for (lauf = 1; lauf <= 10; lauf = lauf+2 ) <br />
{<br />
summe = summe + lauf;<br />
}<br />
</pre><br />
Das Äquivalent als <tt>while</tt>-Schleife:<br />
<pre><br />
int lauf = 1; /* Anfangswerte */<br />
int summe = 0;<br />
<br />
while (lauf <= 10) /* Bedingung */<br />
{<br />
summe = summe + lauf;<br />
lauf += 2; /* Inkrement */<br />
}<br />
</pre><br />
<br />
<br />
In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.<br />
<br />
'''Erklärung:''' <br />
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. <br />
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. <br />
<tt>lauf = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um&nbsp;2 erhöht wird.<br />
<br />
=Ein- und Ausgabe=<br />
<br />
==Bildschirm-Ausgabe==<br />
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.<br />
<br />
Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, </tt>char</tt>, <tt>double</tt>...) sein! <br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int zahl1 = 12;<br />
char zeichen1 = 'A';<br />
<br />
printf ("Das ist Text, und er wird als solcher ausgegeben. \n");<br />
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile. <br />
<br />
Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus. <br />
<br />
In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert. <br />
<br />
Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen! <br />
<br />
==Tastatur-Eingabe==<br />
<br />
Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.<br />
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>: <br />
<br />
<pre><br />
int zahl1;<br />
char zeichen1;<br />
<br />
printf ("Bitte geben Sie eine Zahl ein: ");<br />
scanf ("%d", &zahl1);<br />
printf ("Geben Sie einen Zeichen ein: ");<br />
scanf ("%c", &zeichen1);<br />
</pre><br />
<br />
Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.<br />
<br />
Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!<br />
<br />
Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference"). <br />
<br />
<br />
=Allgemeines zu Unterprogrammen=<br />
Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen.<br />
Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen: <br />
<br />
==Funktionen==<br />
'''Syntax:''' Rückgabe-Typ Name(Parameterliste);<br />
<br />
Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln: <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int hoch2 (int param1)<br />
{<br />
int zahl;<br />
zahl = param1 * param1;<br />
return zahl;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl1, ergebnis;<br />
<br />
printf ("Bitte Zahl eingeben: ");<br />
scanf ("%d",&zahl1);<br />
<br />
ergebnis = hoch2 (zahl1);<br />
<br />
printf ("%d hoch 2 = %d\n",zahl1, ergebnis);<br />
printf ("5 hoch 2 = %d\n", hoch2(5));<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. <br />
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. <br />
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.<br />
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. <br />
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert. <br />
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an<br />
variable = Funktion (Parameter);<br />
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile). <br />
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.<br />
<br />
==Prozedur==<br />
'''Syntax:''' <tt>void Name (Parameterliste)</tt><br />
<br />
Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp <tt>void</tt>, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede: <br />
<br />
Als Rückgabe-Datentyp wird <tt>void</tt> angegeben. <br />
Einer Variablen kann daher nicht der Rückgabewert einer <tt>void</tt>-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int param1)<br />
{<br />
printf ("Der Wert der Variablen ist: %d\n", param1);<br />
}<br />
<br />
int main(void)<br />
{<br />
int zahl1 = 4;<br />
<br />
ausgeben (23);<br />
ausgeben (zahl1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Durch den Befehl "<tt>ausgeben(23)</tt>" wird die Prozedur "<tt>ausgeben</tt>" mit dem Parameter <tt>23</tt> aufgerufen. <tt>param1</tt> hat also den Wert <tt>23</tt>. Die einzige Anweisung innerhalb der Prozedur ist <tt>printf</tt>, was nun ausgeführt wird. <br />
Der zweite Aufruf von <tt>ausgeben</tt> erfolgt mit dem Parameter <tt>zahl1</tt>, also wird <tt>param1</tt> der Wert 4 zugewiesen. Dieser wird nun wieder mittels <tt>printf</tt> ausgeben. <br />
<br />
Unterprogramme ohne Parameter<br />
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur <tt>void</tt> stehen. Das <tt>void</tt> bedeutet "die Funktion erhält keine Parameter". "<tt>void main (void)</tt>" bedeutet also: "Erstelle ein Unterprogramm Namens <tt>main</tt>, das keinen Rückgabewert und keine Parameter hat".<br />
<br />
{{FarbigerRahmen |<br />
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:<br />
foo();<br />
}}<br />
<br />
==Prototypen==<br />
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?<br />
Um dies zu erreichen, gibt es zwei Möglichkeiten: <br />
<br />
Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! <br />
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. <br />
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt&nbsp;<tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). <br />
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int zahl); /* Der Prototyp */<br />
<br />
int main (void)<br />
{<br />
ausgeben (12);<br />
<br />
return 0;<br />
}<br />
<br />
void ausgeben (int zahl) /* Die eigentliche Prozedur */<br />
{<br />
printf ("Ausgabe: %d\n", zahl);<br />
}<br />
</pre><br />
<br />
==Parameterübergabe==<br />
<br />
Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.<br />
Das hat folgende Auswirkungen:<br />
<br />
# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!<br />
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger | Zeiger]] übergeben werden.<br />
# Werden [[#Strukturen | Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.<br />
<br />
<br />
Beispiele:<br />
<pre><br />
void erhoehe (int x)<br />
{<br />
x = x + 1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int a = 0;<br />
erhoehe(a);<br />
/* a ist immer noch 0 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.<br />
<br />
<pre><br />
void erhoehe (int *x)<br />
{<br />
/* erhöhe den Wert an der Adresse x um eins */<br />
*x = *x + 1;<br />
}<br />
<br />
int main(void)<br />
{<br />
int a = 0;<br />
erhoehe (&a);<br />
/* a ist jetzt 1 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&amp;</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die<br />
Adresse des Originals <tt>a</tt> und kann direkt mit dem Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.<br />
<br />
<br />
'''Besonderheit bei Feldern'''<br />
<br />
Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines<br />
Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.<br />
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf<br />
den Originaldaten arbeiten und diese verändern.<br />
<br />
Beispiel:<br />
<pre><br />
void erhoehe (int x[])<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
<br />
Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:<br />
<br />
<pre><br />
/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */<br />
void erhoehe (int *x)<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
}<br />
</pre><br />
<br />
{{FarbigerRahmen |<br />
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.<br />
}}<br />
<br />
=Standard-Funktionen=<br />
<br />
==strcpy==<br />
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren! <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri1[21], eingabe[21];<br />
<br />
strcpy (stri1, "hallo");<br />
<br />
printf ("Der 1. String: %s\n", stri1);<br />
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");<br />
scanf ("%s", eingabe);<br />
strcpy (stri1, eingabe);<br />
printf ("\n%s = %s", stri1, eingabe);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Hinweis:''' <br />
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&amp;</tt> bei <tt>scanf</tt> angeben!<br />
<br />
'''Erklärung:''' <br />
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen. <br />
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. <br />
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings. <br />
Sie werden gebeten, eine String einzugeben. <br />
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert. <br />
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.<br />
<br />
==strlen==<br />
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern. <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri[21];<br />
<br />
strcpy (stri, "hallo");<br />
printf ("Der String ist %d Zeichen lang", strlen (stri));<br />
}<br />
</pre><br />
<br />
Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc. <br />
<br />
<br />
<br />
===Zeiger als Parameter===<br />
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.<br />
Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable"). <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void erhoehe (int *zeiger)<br />
{<br />
*zeiger = *zeiger+1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl;<br />
<br />
printf ("Zahl eingeben: ");<br />
scanf ("%d", &zahl);<br />
erhoehe (&zahl);<br />
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
==Parameter von <tt>main</tt>==<br />
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen. <br />
<pre><br />
int main (int argc, char *argv[], char* environ[])<br />
</pre><br />
<br />
Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge&nbsp;0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.<br />
<pre><br />
#include <stdio.h><br />
#include <stdlib.h><br />
<br />
int main (int argc, char *argv[], char * environ[])<br />
{<br />
int i;<br />
<br />
printf ("Es wurden %d Parameter angegeben", argc);<br />
<br />
for (i=0; i < argc; i++) <br />
printf ("Parameter %d: %s\n", i, argv[i]);<br />
<br />
for (i = 0; environ[i] != NULL; ++i) <br />
printf ("environ[%d] = %s\n", i, environ[i]);<br />
}<br />
</pre><br />
<br />
;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement &ndash; wie in C üblich &ndash; das Element <tt><tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen! <br />
<br />
=Liste der Schlüsselworte=<br />
<br />
* [[#Speicherklassen|auto]]<br />
* break<br />
* [[#Elementare Datentypen|double]]<br />
* [[#Elementare Datentypen|char]]<br />
* case<br />
* [[#Konstanten|const]]<br />
* continue<br />
* default<br />
* do<br />
* else<br />
* enum<br />
* [[#Speicherklassen|extern]]<br />
* [[#Elementare Datentypen|float]]<br />
* for<br />
* goto<br />
* if<br />
* [[##Elementare Datentypen|int]]<br />
* [[#Elementare Datentypen|long]]<br />
* return<br />
* [[#Speicherklassen|register]]<br />
* [[#Elementare Datentypen|short]]<br />
* signed<br />
* sizeof<br />
* [[#Speicherklassen|static]]<br />
* [[#Strukturen|struct]]<br />
* switch<br />
* typedef<br />
* [[#Unions|union]]<br />
* unsigned<br />
* [[#Elementare Datentypen|void]]<br />
* volatile<br />
* while<br />
<br />
Baustelle<br />
<br />
=Liste der Operatoren=<br />
<br />
Baustelle<br />
<br />
<font color="blue"><></font><br />
<br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung || Nebeneffekte<br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> == <font color="blue"><Ausdruck></font></tt> || ist gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> != <font color="blue"><Ausdruck></font></tt> || ist nicht gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt; <font color="blue"><Ausdruck></font></tt> || ist kleiner <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt;= <font color="blue"><Ausdruck></font></tt> || ist kleiner oder gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt; <font color="blue"><Ausdruck></font></tt> || ist größer <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt;= <font color="blue"><Ausdruck></font></tt> || ist größer oder gleich <br />
|-<br />
| <tt>&amp; <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> = <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> += <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> -= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> *= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> /= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ^= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> &= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> |= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>++ <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ++</tt> || <br />
|-<br />
| <tt>-- <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> --</tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> && <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> <nowiki>||</nowiki> <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>~ <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>! <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Type></font>) <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> + <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> - <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> * <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> / <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> % <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> %= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Bedingung></font>) ? <font color="blue"><Ausdruck></font> : <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Struct></font>.<font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Zeiger-auf-Struct></font>-><font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|}<br />
<br />
<br />
'''Autoren'''<br />
* Plasma<br />
* Bernd<br />
* [[Benutzer:SprinterSB|SprinterSB]]<br />
<br />
'''Quellen:'''<br />
* Kernighan und Ritchie - Buch<br />
* Christian Wirth , C Tutorial<br />
* Prof. Dr. J. Dankert Ausführungen<br />
<br />
=Siehe auch=<br />
* [[avr-gcc]]<br />
* [[Compiler]]<br />
* [[WinAVR]]<br />
* [[Fallstricke bei der C-Programmierung]]<br />
<br />
=Weblinks=<br />
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]<br />
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]<br />
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]<br />
<br />
[[Kategorie:Quellcode C|!]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=C-Tutorial&diff=8119C-Tutorial2006-07-05T11:05:54Z<p>Roberto: /* Blöcke */</p>
<hr />
<div>Ein kurzer Einblick in die Programmiersprache C<br />
=Allgemeines=<br />
C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.<br />
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.<br />
<br />
C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu lediglich einen anderen Compiler, und Inline-Assembler Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden. <br />
<br />
==Geschichte==<br />
;1971: C wird entwickelt<br />
;1978: Kernighan und Ritchie definieren die Sprache.<br />
;1983: ANSI und ISO standardisieren C.<br />
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.<br />
<br />
=Aufbau eines C-Programmes=<br />
<!-- <br />
<br />
C-Programme haben keinen fixen Aufbau wie z.B. Pascal. Es gibt zwar gewisse Regeln, aber sonst sind dem Programmierer alle Freiheiten überlassen. Der folgende "Beispiel-Aufbau" ist daher nicht zwingend und kann durchaus verändert werden.<br />
<br />
Natürlich haben C-Programme einen fixen Aufbau! Ebenso wie Pascal-Programme auch unterliegen sie einer strikten Grammatik! <br />
Auskommentiert --[[Benutzer:SprinterSB|SprinterSB]] 10:23, 17. Feb 2006 (CET)<br />
--><br />
Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau. <br />
<pre><br />
#include <stdio.h><br />
<br />
int Zahl1;<br />
char Zeichen1;<br />
<br />
int main (void)<br />
{<br />
int zahl2;<br />
<br />
/* Anweisungen */<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Beschreibung (die Erklärungen folgen): <br />
<br />
;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.<br />
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.<br />
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert. <br />
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.<br />
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.<br />
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert. <br />
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.<br />
;return 0;: Gibt den Wert&nbsp;0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.<br />
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.<br />
<br />
=Das Hauptprogramm main=<br />
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm. <br />
<br />
Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer &ndash; üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt. <br />
<br />
Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!<br />
<pre><br />
/* <br />
* void Definition von main ist nur beim Controller üblich<br />
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main<br />
* kein Fehler/Warnung erzeugt wird. <br />
*/<br />
void main (void)<br />
{<br />
...<br />
}<br />
</pre><br />
<br />
=Blöcke=<br />
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung.<br />
Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende": <br />
<br />
<pre><br />
int main (void)<br />
{ /* der Block "main" beginnt */<br />
int zahl;<br />
<br />
{ /* ein Block beginnt */<br />
/* hier können Deklarationen und Anweisungen stehen */<br />
} /* der Block endet */<br />
<br />
return 0;<br />
} /* "main" endet */<br />
</pre><br />
<br />
'''Bemerkung:''' <br />
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!<br />
<br />
=Datentypen=<br />
==Elementare Datentypen==<br />
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.<br />
<br />
;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!<br />
<br />
===int, char, short, long (ganze Zahlen)===<br />
In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen. <br />
<br />
Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann recht der Wertebereich von <tt>-2<sup>''b''-1</sup></tt> bis zu <tt>2<sup>''b''-1</sup>-1</tt>.<br />
<br />
Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2<sup>''b''</sup>-1</tt>, wenn der Typ ''b'' Bits breit ist.<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs<br />
|- <br />
| 8 || <tt>char</tt> <br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -128<br />0<br />
| align="right" | 127<br />255<br />
|- <br />
| 16 || <tt>short</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -32.768<br />0<br />
| align="right" | 32.767<br />65.535<br />
|- <br />
| 32 || <tt>long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -2.147.483.648<br />0<br />
| align="right" | 2.147.483.647<br />4.294.967.295<br />
|- <br />
| 64 || <tt>long long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -9.223.372.036.854.775.808<br />0<br />
| align="right" | 9.223.372.036.854.775.807<br />18.446.744.073.709.551.615<br />
|-<br />
|8, 16, 32, 64<br/><br />
| <tt>int</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
|plattform-/compilerabhängig<br />
|plattform-/compilerabhängig<br />
|}<br />
</center><br />
<br />
==== Boolean (Logische Variablen)====<br />
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.<br />
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.<br />
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert&nbsp;1 haben muß. Sie muß lediglich ungleich&nbsp;0 sein!<br />
<br />
====char (Zeichen)====<br />
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen. <br />
<br />
Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!<br />
<br />
===float, double (Gleitkommazahlen)===<br />
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. <br />
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.<br />
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.<br />
<br />
===void===<br />
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.<br />
<br />
==Zeiger==<br />
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''. <br />
<br />
Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein&nbsp;<tt>&</tt> voranstellt. Die Umkehrung davon &ndash; also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist &ndash; erledigt ein vorgestellter&nbsp;<tt>*</tt>. Der Operator &nbsp;<tt>*</tt> gibt also den ''Inhalt'' der Adresse.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int * zeiger;<br />
int zahl;<br />
<br />
zeiger = &zahl;<br />
*zeiger = 12;<br />
<br />
printf ("%d = %d", zahl, *zeiger);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der&nbsp;<tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:<br />
int * zeiger, zahl;<br />
<br />
Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator&nbsp;<tt>&</tt> von <tt>zahl</tt>:<br />
zeiger = &zahl; <br />
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>). <br />
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.<br />
<br />
==Zusammengesetzte Datentypen==<br />
===Arrays===<br />
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays &ndash; teilweise auch als ''Felder'' bezeichnet &ndash; zu verwenden.<br />
<br />
In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis </tt>Zahl_99</tt> arbeiten!<br />
<br />
'''Syntax:''' Datentyp Variablenname[Anzahl]<br />
<br />
Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für 3 Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes. <br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int i;<br />
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */<br />
<br />
for (i=0; i<10; i++)<br />
{<br />
printf ("Bitte Zahl %d eingeben: ", i);<br />
scanf ("%d", & zahlen[i]);<br />
printf ("\n");<br />
}<br />
printf ("Super!\n");<br />
<br />
for (i=0; i<10; i++) <br />
printf ("Zahl %d ist: %d\n", i, zahlen[i]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen:''' <br />
Zuerst wird ein 10 int-Variablen großes Array angelegt. <br />
In dieses wird nun der Reihe nach 10 Zahlen eingelesen. <br />
Anschließend werden alle 10 Zahlen ausgegeben. <br />
<br />
{{FarbigerRahmen|<br />
'''Merke:'''<br />
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!<br />
}}<br />
<br />
===Strings (Zeichenketten)===<br />
Ein String ist nicht sanderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.<br />
<br />
Die Definition eines Strings erfolgt also genauso wie bei Arrays:<br />
char string[21];<br />
<br />
Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert". <br />
<br />
Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.<br />
<br />
===Mehrdimensionale Arrays===<br />
Manchmal benötigen mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.<br />
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:<br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int x,y;<br />
int feld[3][5];<br />
<br />
for (x=0; x<3; x++) <br />
{<br />
for (y=0; y<5; y++)<br />
{<br />
printf ("Feldwert x: %d, y: %d ", x, y);<br />
scanf ("%d", & feld[x][y]);<br />
printf ("\n");<br />
}<br />
}<br />
<br />
for(x=0; x<3; x++) <br />
for (y=0; y<5; y++) <br />
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Erklärung:''' <br />
<br />
Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt. <br />
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>. <br />
Zum Schluß werden alle Werte noch einmal ausgegeben.<br />
<br />
===Strukturen===<br />
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden: <br />
<br />
<pre><br />
struct Person <br />
{<br />
int id;<br />
char vname[20], nname[20];<br />
char telnr[15];<br />
int alter;<br />
};<br />
</pre><br />
<br />
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein. <br />
Dann werden in dieser Struktur vier Komponenten angelege: drei Strings und zwei <tt>int</tt>. <br />
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach <br />
struct Person Variablenname;<br />
an. <br />
<br />
Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:<br />
<pre><br />
struct Person hubert, klaus;<br />
<br />
hubert.alter = 32;<br />
klaus.alter = hubert.alter + 1;<br />
</pre><br />
<br />
===Unions===<br />
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.<br />
<pre><br />
union Daten <br />
{<br />
int id;<br />
<br />
struct u_double<br />
{<br />
int id;<br />
double wert;<br />
};<br />
<br />
struct Person u_person;<br />
<br />
struct u_pointer<br />
{<br />
int id;<br />
union Daten * p1;<br />
union Daten * p2;<br />
};<br />
};<br />
<br />
union Daten data;<br />
</pre><br />
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_double</tt>, <tt>u_person</tt> und <tt>u_pointer</tt>. Die Große der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden.<br />
<br />
Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:<br />
<pre><br />
typedef union<br />
{<br />
unsigned long as_long;<br />
unsignen chat as_byte[4];<br />
} data32_t;<br />
</pre><br />
Dies überlagert einen <tt>unsigned long</tt> &ndash; also eine 32-Bit-Zahl &ndash; mit vier Bytes.<br />
<pre><br />
data32_t wert;<br />
<br />
wert.as_long = 0x12345678;<br />
wert.as_byte[0] = 0xab;<br />
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */<br />
</pre><br />
<br />
=Variablen=<br />
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.<br />
<br />
==Variablennamen==<br />
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.<br />
<br />
Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.<br />
==Anlegen von Variablen==<br />
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung! <br />
<pre><br />
int Zahl1, Zahl2;<br />
char Zeichen;<br />
<br />
int main (void)<br />
{<br />
float gleitZahl;<br />
/* Anweisungen */<br />
<br />
return 0;<br />
}<br />
</pre><br />
;Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].<br />
<br />
==Zuweisungen==<br />
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]]. <br />
<pre><br />
int main (void)<br />
{<br />
int zahl1, zahl2 = 12;<br />
char zeichen1 = 'A';<br />
<br />
zahl1 = 52;<br />
zeichen1 = zeichen1 + 1; <br />
<br />
return 0;<br />
}<br />
</pre><br />
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>). <br />
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen. <br />
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.<br />
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.<br />
<br />
==Zuweisungen bei float==<br />
Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt: <br />
floatVariable = 3.14;<br />
Zusätzlich kann eine Zehnerpotenz angegeben werden:<br />
floatVariable2 = -1.234E-6;<br />
Dadurch wird der erst Wert mit 10<sup><tt>-</tt>6</sup> multipliziert, der Wert der Variablen ist also <br />
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.<br />
<br />
==Zuweisungen bei logischen Variablen==<br />
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr". <br />
intVariable = !0; /* entspricht "wahr" */<br />
intVariable = 0; /* entspricht "unwahr" */<br />
<br />
==Vergleich von Variablen==<br />
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln: <br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|}<br />
</center><br />
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl. <br />
intVariable = zahl1 <= zahl2;<br />
das komplette Beispiel zeigt es deutlicher:<br />
<pre><br />
int i;<br />
int z1, z2;<br />
<br />
z1 = 5;<br />
z2 = 100;<br />
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */<br />
<br />
printf ("Ergebnis: %d\n", i);<br />
</pre><br />
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").<br />
<br />
==Konstanten==<br />
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:<br />
const ''datentyp'' name = value; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. <br />
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.<br />
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit<br />
* ((float*) &PI) = 2;<br />
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.<br />
<br />
Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist<br />
void foo (const char * str, ...);<br />
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.<br />
<br />
Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:<br />
void foo (char * const str, ...);<br />
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>. Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim&nbsp;<tt>*</tt> auf: Steht das <tt>const</tt> links vom&nbsp;<tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides &ndash; also den Zeiger und sein Ziel &ndash; als konstant zu markieren.<br />
<br />
==Gültigkeitsbereich==<br />
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln: <br />
<br />
;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.<br />
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.<br />
<br />
==Speicherklassen==<br />
Jede Variable in C gehört zu einer bestimmten Speicherklasse<br />
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.<br />
;<tt>extern</tt>: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].<br />
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.<br />
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable &ndash; falls möglich &ndash; als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!<br />
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.<br />
<br />
=Ausdrücke=<br />
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.<br />
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.<br />
<br />
Einfache Beispiele für Ausdrücke sind also z.B.:<br />
1<br />
a<br />
'a'<br />
1 + a<br />
a == 1<br />
<br />
Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.<br />
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,<br />
und wei man damit neue Ausdrücke aufbauen kann.<br />
<br />
==Lvalues==<br />
<br />
Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.<br />
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.<br />
<br />
Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:<br />
a = 1;<br />
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie<br />
a+1 = 2;<br />
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":<br />
"ungültiger Wert in Zuweisung"<br />
<br />
Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante&nbsp;4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung&nbsp;<tt>*</tt> wird an die Adresse&nbsp;4 im Speicher eine&nbsp;3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.<br />
* ((unsigned int *) 4) = 3;<br />
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue<br />
<br />
==Logische (boolsche) Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a &amp;&amp; b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr<br />
|-<br />
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr<br />
|-<br />
|<tt>a == b</tt> || gleich<br />
|-<br />
|<tt>a != b</tt> || ungleich<br />
|-<br />
|<tt>a <= b</tt> || kleiner oder gleich<br />
|-<br />
|<tt>a < b</tt> || kleiner als<br />
|-<br />
|<tt>a >= b</tt> || glösser oder gleich<br />
|-<br />
|<tt>a > b</tt> || grösser als<br />
|-<br />
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa<br />
|}<br />
</center><br />
<br />
Eine interessante Eigenheit der Operatoren <tt>&amp;&amp;</tt> und <tt>||</tt> ist, dass<br />
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden<br />
dabei immer von links nach rechts ausgewertet.<br />
<br />
Beispiel:<br />
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */<br />
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */<br />
<br />
<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,<br />
die eine aufwändige Operation durchführt.<br />
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder<br />
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.<br />
<br />
Wo ist also der Unterschied?<br><br />
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,<br />
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.<br />
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte<br />
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.<br />
<br />
==Arithmetische Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a + b</tt> || Summe (Addition)<br />
|-<br />
|<tt>a - b</tt> || Differenz (Subtraktion)<br />
|-<br />
|<tt>a * b</tt> || Produkt (Multiplikation)<br />
|-<br />
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)<br />
|-<br />
|<tt>a % b</tt> || Rest bei Division (Modulo)<br />
|-<br />
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)<br />
|}<br />
</center><br />
==Bit-Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a & b</tt> || bitweise und (and)<br />
|-<br />
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)<br />
|-<br />
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)<br />
|-<br />
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)<br />
|}<br />
</center><br />
==Index-Operator bei Arrays==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a<br />
|}<br />
</center><br />
<br />
Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:<br />
<br />
# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein<br />
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)<br />
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!<br />
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung<br />
<br />
==Komponenten-Auswahl bei Structs und Unions==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a<br />
|}<br />
</center><br />
<br />
==Adress-Operator und Dereferenzierung==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>&amp;a</tt> || Speicheradresse der Variablen <tt>a</tt><br />
|-<br />
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht<br />
|-<br />
||<tt>a-&gt;b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht<br />
|}<br />
</center><br />
<br />
Der Adressoperator & kann auf Variablen angewendet werden und<br />
gibt die Startadresse der Variablen im Speicher zurück.<br />
<br />
Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält<br />
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der<br />
an dieser Adresse steht, wird der Operator * vorangestellt.<br />
<br />
Beispiel:<br />
<pre><br />
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */<br />
<br />
/* z ist ein Zeiger auf eine Integervariable und enthält somit<br />
die Speicheradresse einer Integervariablen<br />
*/<br />
int *z; <br />
<br />
/* Verwendung des Adressoperators... */<br />
z = &x; /* weise z die Speicheradresse von x zu */<br />
<br />
/* Verwendung der Dereferenzierung */<br />
/* erhöhe den Wert, der bei Adresse z steht um eins */<br />
*z = *z + 1;<br />
<br />
/* da z auf x zeigt, hat auch x jetzt den Wert 6 */<br />
</pre><br />
<br />
Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff<br />
auf ein Element eine abkürzende Schreibweise möglich:<br />
<br />
Statt <br />
(*strukturZeiger).element<br />
kann geschrieben werden<br />
strukturZeiger->element<br />
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch<br />
auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu<br />
einer Änderung '''irgendeiner''' Speicherstelle:<br />
<br />
<pre><br />
int *z; /* z ist ein Zeiger auf einen Integer */<br />
<br />
/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.<br />
z enthält irgendeine(!) Adresse<br />
*/<br />
<br />
/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */<br />
*z = *z + 1;<br />
</pre><br />
<br />
Viele C-Compiler (z.B. gcc) erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!<br />
}}<br />
<br />
==Cast-Operator==<br />
<br />
Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.<br />
<br />
Um zum Beispiel aus einem Float ein Integer zu machen:<br />
var = (int) 5.60;<br />
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.<br />
<br />
Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:<br />
int * addr;<br />
addr = (int*) 0x1234;<br />
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder<br />
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in<br />
eine Zahl oder umgekehrt zu wandeln:<br />
<br />
<pre><br />
#include <stdio.h><br />
int main(int argc, char ** argv)<br />
{<br />
char text[] = "5.6";<br />
int zahl = (int)text;<br />
<br />
printf("%d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator<br />
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.<br />
}}<br />
<br />
==Komma Operator==<br />
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.<br />
Die Auswertung erfolgt von links nach rechts.<br />
<br />
Solche Konstrukte sieht man manchmal in Abfragen wie<br />
FILE *file;<br />
if (file = fopen ("foo.exe", "r"), file != NULL)<br />
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,<br />
wenn <tt>file</tt> nicht der Nullpointer ist.<br />
<br />
==Zuweisungen und Operatoren mit Nebeneffekt==<br />
===Bedingte Zuweisung===<br />
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;<br />
<br />
<!--<br />
Kein ANSI-C<br />
--[[Benutzer:SprinterSB|SprinterSB]] 17:15, 29. Jun 2006 (CEST)<br />
==Blöcke==<br />
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.<br />
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks. <br />
Der Block muss un runden Klammern stehen:<br />
int sum;<br />
sum = ({<br />
int i, s = 0;<br />
for (i=1; i<= 100; i++)<br />
s += i;<br />
s;<br />
});<br />
<br />
Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc, <br />
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer<br />
Instruktion nicht machbar wäre:<br />
<pre><br />
#define PSTR(s) \<br />
({ \ <br />
static char __c[] PROGMEM = (s); \<br />
__c; \<br />
})<br />
</pre><br />
--><br />
<br />
==Reihenfolge der Auswertung==<br />
<br />
=Kontrollanweisungen=<br />
<br />
==Boolsche Logik==<br />
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird). <br />
<br />
b1= b2 && b3;<br />
<br />
<br />
Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).<br />
<br />
<br />
b1= b2 || b3;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.<br />
<br />
<br />
b1= !b2;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".<br />
<br />
==<tt>if</tt>-Anweisung==<br />
Syntax: IF (Bedingung) Anweisung;<br />
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:<br />
<br />
[[bild:ifthenelse.png]]<br />
<br />
Und in C schreibt man:<br />
<pre><br />
if (Bedingung) /* WENN */<br />
{ /* DANN */<br />
Anweisung1;<br />
Anweisung2;<br />
...<br />
}<br />
else<br />
{ /* SONST */<br />
Anweisung3;<br />
Anweisung4;<br />
...<br />
}<br />
</pre><br />
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt. <br />
<br />
Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki><br />
<br />
<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki><br />
<br />
<br />
Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.<br />
}}<br />
<br />
==<tt>switch</tt>-Anweisung==<br />
Syntax: <br />
<pre><br />
switch(ausdruck) {<br />
case wert1:<br />
Anweisungen1...<br />
case wert2:<br />
Anweisungen2...<br />
case wert3:<br />
Anweisungen3...<br />
...<br />
default:<br />
Anweisungen4...<br />
}<br />
</pre><br />
<br />
Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter<br />
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der<br />
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt><br />
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.<br />
<br />
<b>Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines<br />
<tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!</b><br />
<br />
Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.<br />
Der <tt>default</tt>-Abschnitt ist optional, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,<br />
wenn er verwendet wird.<br />
<br />
<br />
==Schleifen==<br />
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.<br> <br />
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird. <br />
<br />
===<tt>while</tt>-Schleife===<br />
'''Syntax:''' while (Bedingung) { Anweisung; }<br />
<br />
Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block! <br />
<br />
<pre><br />
Zahl1=0;<br />
while (Zahl1<3)<br />
{<br />
Zahl1=Zahl1+1;<br />
Zahl2=Zahl2*2;<br />
}<br />
</pre><br />
<br />
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.<br />
===<tt>do</tt>-<tt>while</tt>-Schleife===<br />
'''Syntax:''' do { Anweisung; }while (Bedingung);<br />
<br />
Die DO WHILE-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird <br />
<br />
<pre><br />
int i=2;<br />
do <br />
{<br />
i = i*i; /* i quadrieren */<br />
printf ("i = %d\n", i);<br />
}<br />
while (i < 20);<br />
</pre><br />
<br />
Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.<br />
<br />
===<tt>for</tt>-Schleife===<br />
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }<br />
<br />
Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.<br />
<br />
Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.<br />
<br />
Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet. <br />
<br />
<pre><br />
int lauf;<br />
int summe = 0;<br />
<br />
for (lauf = 1; lauf <= 10; lauf = lauf+2 ) <br />
{<br />
summe = summe + lauf;<br />
}<br />
</pre><br />
Das Äquivalent als <tt>while</tt>-Schleife:<br />
<pre><br />
int lauf = 1; /* Anfangswerte */<br />
int summe = 0;<br />
<br />
while (lauf <= 10) /* Bedingung */<br />
{<br />
summe = summe + lauf;<br />
lauf += 2; /* Inkrement */<br />
}<br />
</pre><br />
<br />
<br />
In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.<br />
<br />
'''Erklärung:''' <br />
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. <br />
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. <br />
<tt>lauf = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um&nbsp;2 erhöht wird.<br />
<br />
=Ein- und Ausgabe=<br />
<br />
==Bildschirm-Ausgabe==<br />
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.<br />
<br />
Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, </tt>char</tt>, <tt>double</tt>...) sein! <br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int zahl1 = 12;<br />
char zeichen1 = 'A';<br />
<br />
printf ("Das ist Text, und er wird als solcher ausgegeben. \n");<br />
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile. <br />
<br />
Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus. <br />
<br />
In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert. <br />
<br />
Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen! <br />
<br />
==Tastatur-Eingabe==<br />
<br />
Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.<br />
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>: <br />
<br />
<pre><br />
int zahl1;<br />
char zeichen1;<br />
<br />
printf ("Bitte geben Sie eine Zahl ein: ");<br />
scanf ("%d", &zahl1);<br />
printf ("Geben Sie einen Zeichen ein: ");<br />
scanf ("%c", &zeichen1);<br />
</pre><br />
<br />
Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.<br />
<br />
Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!<br />
<br />
Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference"). <br />
<br />
<br />
=Allgemeines zu Unterprogrammen=<br />
Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen.<br />
Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen: <br />
<br />
==Funktionen==<br />
'''Syntax:''' Rückgabe-Typ Name(Parameterliste);<br />
<br />
Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln: <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int hoch2 (int param1)<br />
{<br />
int zahl;<br />
zahl = param1 * param1;<br />
return zahl;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl1, ergebnis;<br />
<br />
printf ("Bitte Zahl eingeben: ");<br />
scanf ("%d",&zahl1);<br />
<br />
ergebnis = hoch2 (zahl1);<br />
<br />
printf ("%d hoch 2 = %d\n",zahl1, ergebnis);<br />
printf ("5 hoch 2 = %d\n", hoch2(5));<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. <br />
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. <br />
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.<br />
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. <br />
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert. <br />
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an<br />
variable = Funktion (Parameter);<br />
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile). <br />
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.<br />
<br />
==Prozedur==<br />
'''Syntax:''' <tt>void Name (Parameterliste)</tt><br />
<br />
Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp <tt>void</tt>, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede: <br />
<br />
Als Rückgabe-Datentyp wird <tt>void</tt> angegeben. <br />
Einer Variablen kann daher nicht der Rückgabewert einer <tt>void</tt>-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int param1)<br />
{<br />
printf ("Der Wert der Variablen ist: %d\n", param1);<br />
}<br />
<br />
int main(void)<br />
{<br />
int zahl1 = 4;<br />
<br />
ausgeben (23);<br />
ausgeben (zahl1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Durch den Befehl "<tt>ausgeben(23)</tt>" wird die Prozedur "<tt>ausgeben</tt>" mit dem Parameter <tt>23</tt> aufgerufen. <tt>param1</tt> hat also den Wert <tt>23</tt>. Die einzige Anweisung innerhalb der Prozedur ist <tt>printf</tt>, was nun ausgeführt wird. <br />
Der zweite Aufruf von <tt>ausgeben</tt> erfolgt mit dem Parameter <tt>zahl1</tt>, also wird <tt>param1</tt> der Wert 4 zugewiesen. Dieser wird nun wieder mittels <tt>printf</tt> ausgeben. <br />
<br />
Unterprogramme ohne Parameter<br />
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur <tt>void</tt> stehen. Das <tt>void</tt> bedeutet "die Funktion erhält keine Parameter". "<tt>void main (void)</tt>" bedeutet also: "Erstelle ein Unterprogramm Namens <tt>main</tt>, das keinen Rückgabewert und keine Parameter hat".<br />
<br />
{{FarbigerRahmen |<br />
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:<br />
foo();<br />
}}<br />
<br />
==Prototypen==<br />
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?<br />
Um dies zu erreichen, gibt es zwei Möglichkeiten: <br />
<br />
Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! <br />
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. <br />
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt&nbsp;<tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). <br />
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int zahl); /* Der Prototyp */<br />
<br />
int main (void)<br />
{<br />
ausgeben (12);<br />
<br />
return 0;<br />
}<br />
<br />
void ausgeben (int zahl) /* Die eigentliche Prozedur */<br />
{<br />
printf ("Ausgabe: %d\n", zahl);<br />
}<br />
</pre><br />
<br />
==Parameterübergabe==<br />
<br />
Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.<br />
Das hat folgende Auswirkungen:<br />
<br />
# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!<br />
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger | Zeiger]] übergeben werden.<br />
# Werden [[#Strukturen | Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.<br />
<br />
<br />
Beispiele:<br />
<pre><br />
void erhoehe (int x)<br />
{<br />
x = x + 1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int a = 0;<br />
erhoehe(a);<br />
/* a ist immer noch 0 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.<br />
<br />
<pre><br />
void erhoehe (int *x)<br />
{<br />
/* erhöhe den Wert an der Adresse x um eins */<br />
*x = *x + 1;<br />
}<br />
<br />
int main(void)<br />
{<br />
int a = 0;<br />
erhoehe (&a);<br />
/* a ist jetzt 1 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&amp;</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die<br />
Adresse des Originals <tt>a</tt> und kann direkt mit dem Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.<br />
<br />
<br />
'''Besonderheit bei Feldern'''<br />
<br />
Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines<br />
Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.<br />
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf<br />
den Originaldaten arbeiten und diese verändern.<br />
<br />
Beispiel:<br />
<pre><br />
void erhoehe (int x[])<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
<br />
Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:<br />
<br />
<pre><br />
/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */<br />
void erhoehe (int *x)<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
}<br />
</pre><br />
<br />
{{FarbigerRahmen |<br />
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.<br />
}}<br />
<br />
=Standard-Funktionen=<br />
<br />
==strcpy==<br />
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren! <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri1[21], eingabe[21];<br />
<br />
strcpy (stri1, "hallo");<br />
<br />
printf ("Der 1. String: %s\n", stri1);<br />
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");<br />
scanf ("%s", eingabe);<br />
strcpy (stri1, eingabe);<br />
printf ("\n%s = %s", stri1, eingabe);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Hinweis:''' <br />
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&amp;</tt> bei <tt>scanf</tt> angeben!<br />
<br />
'''Erklärung:''' <br />
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen. <br />
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. <br />
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings. <br />
Sie werden gebeten, eine String einzugeben. <br />
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert. <br />
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.<br />
<br />
==strlen==<br />
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern. <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri[21];<br />
<br />
strcpy (stri, "hallo");<br />
printf ("Der String ist %d Zeichen lang", strlen (stri));<br />
}<br />
</pre><br />
<br />
Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc. <br />
<br />
<br />
<br />
===Zeiger als Parameter===<br />
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.<br />
Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable"). <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void erhoehe (int *zeiger)<br />
{<br />
*zeiger = *zeiger+1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl;<br />
<br />
printf ("Zahl eingeben: ");<br />
scanf ("%d", &zahl);<br />
erhoehe (&zahl);<br />
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
==Parameter von <tt>main</tt>==<br />
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen. <br />
<pre><br />
int main (int argc, char *argv[], char* environ[])<br />
</pre><br />
<br />
Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge&nbsp;0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.<br />
<pre><br />
#include <stdio.h><br />
#include <stdlib.h><br />
<br />
int main (int argc, char *argv[], char * environ[])<br />
{<br />
int i;<br />
<br />
printf ("Es wurden %d Parameter angegeben", argc);<br />
<br />
for (i=0; i < argc; i++) <br />
printf ("Parameter %d: %s\n", i, argv[i]);<br />
<br />
for (i = 0; environ[i] != NULL; ++i) <br />
printf ("environ[%d] = %s\n", i, environ[i]);<br />
}<br />
</pre><br />
<br />
;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement &ndash; wie in C üblich &ndash; das Element <tt><tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen! <br />
<br />
=Liste der Schlüsselworte=<br />
<br />
* [[#Speicherklassen|auto]]<br />
* break<br />
* [[#Elementare Datentypen|double]]<br />
* [[#Elementare Datentypen|char]]<br />
* case<br />
* [[#Konstanten|const]]<br />
* continue<br />
* default<br />
* do<br />
* else<br />
* enum<br />
* [[#Speicherklassen|extern]]<br />
* [[#Elementare Datentypen|float]]<br />
* for<br />
* goto<br />
* if<br />
* [[##Elementare Datentypen|int]]<br />
* [[#Elementare Datentypen|long]]<br />
* return<br />
* [[#Speicherklassen|register]]<br />
* [[#Elementare Datentypen|short]]<br />
* signed<br />
* sizeof<br />
* [[#Speicherklassen|static]]<br />
* [[#Strukturen|struct]]<br />
* switch<br />
* typedef<br />
* [[#Unions|union]]<br />
* unsigned<br />
* [[#Elementare Datentypen|void]]<br />
* volatile<br />
* while<br />
<br />
Baustelle<br />
<br />
=Liste der Operatoren=<br />
<br />
Baustelle<br />
<br />
<font color="blue"><></font><br />
<br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung || Nebeneffekte<br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> == <font color="blue"><Ausdruck></font></tt> || ist gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> != <font color="blue"><Ausdruck></font></tt> || ist nicht gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt; <font color="blue"><Ausdruck></font></tt> || ist kleiner <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &lt;= <font color="blue"><Ausdruck></font></tt> || ist kleiner oder gleich <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt; <font color="blue"><Ausdruck></font></tt> || ist größer <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> &gt;= <font color="blue"><Ausdruck></font></tt> || ist größer oder gleich <br />
|-<br />
| <tt>&amp; <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> = <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> += <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> -= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> *= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> /= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ^= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> &= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> |= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>++ <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> ++</tt> || <br />
|-<br />
| <tt>-- <font color="blue"><Lvalue></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> --</tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> && <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> <nowiki>||</nowiki> <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>~ <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>! <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Type></font>) <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> + <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> - <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> * <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> / <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Ausdruck></font> % <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Lvalue></font> %= <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>(<font color="blue"><Bedingung></font>) ? <font color="blue"><Ausdruck></font> : <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Struct></font>.<font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|-<br />
| <tt><font color="blue"><Zeiger-auf-Struct></font>-><font color="blue"><Komponenten-Bezeichner></font></tt> || <br />
|}<br />
<br />
<br />
'''Autoren'''<br />
* Plasma<br />
* Bernd<br />
* [[Benutzer:SprinterSB|SprinterSB]]<br />
<br />
'''Quellen:'''<br />
* Kernighan und Ritchie - Buch<br />
* Christian Wirth , C Tutorial<br />
* Prof. Dr. J. Dankert Ausführungen<br />
<br />
=Siehe auch=<br />
* [[avr-gcc]]<br />
* [[Compiler]]<br />
* [[WinAVR]]<br />
* [[Fallstricke bei der C-Programmierung]]<br />
<br />
=Weblinks=<br />
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]<br />
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]<br />
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]<br />
<br />
[[Kategorie:Quellcode C|!]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=C-Tutorial&diff=8116C-Tutorial2006-07-05T09:48:41Z<p>Roberto: /* Aufbau eines C-Programmes */</p>
<hr />
<div>Ein kurzer Einblick in die Programmiersprache C<br />
=Allgemeines=<br />
C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.<br />
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.<br />
<br />
C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu lediglich einen anderen Compiler, und Inline-Assembler Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden. <br />
<br />
==Geschichte==<br />
;1971: C wird entwickelt<br />
;1978: Kernighan und Ritchie definieren die Sprache.<br />
;1983: ANSI und ISO standardisieren C.<br />
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.<br />
<br />
=Aufbau eines C-Programmes=<br />
<!-- <br />
<br />
C-Programme haben keinen fixen Aufbau wie z.B. Pascal. Es gibt zwar gewisse Regeln, aber sonst sind dem Programmierer alle Freiheiten überlassen. Der folgende "Beispiel-Aufbau" ist daher nicht zwingend und kann durchaus verändert werden.<br />
<br />
Natürlich haben C-Programme einen fixen Aufbau! Ebenso wie Pascal-Programme auch unterliegen sie einer strikten Grammatik! <br />
Auskommentiert --[[Benutzer:SprinterSB|SprinterSB]] 10:23, 17. Feb 2006 (CET)<br />
--><br />
Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau. <br />
<pre><br />
#include <stdio.h><br />
<br />
int Zahl1;<br />
char Zeichen1;<br />
<br />
int main (void)<br />
{<br />
int zahl2;<br />
<br />
/* Anweisungen */<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Beschreibung (die Erklärungen folgen): <br />
<br />
;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.<br />
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.<br />
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert. <br />
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.<br />
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.<br />
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert. <br />
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.<br />
;return 0;: Gibt den Wert&nbsp;0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.<br />
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.<br />
<br />
=Das Hauptprogramm main=<br />
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm. <br />
<br />
Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer &ndash; üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt. <br />
<br />
Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!<br />
<pre><br />
/* <br />
* void Definition von main ist nur beim Controller üblich<br />
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main<br />
* kein Fehler/Warnung erzeugt wird. <br />
*/<br />
void main (void)<br />
{<br />
...<br />
}<br />
</pre><br />
<br />
=Blöcke=<br />
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung.<br />
Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende": <br />
<br />
<pre><br />
int main (void)<br />
{ /* der Block "main" beginnt */<br />
int zahl;<br />
<br />
{ /* ein Block beginnt */<br />
/* hier können Deklarationen und stehen Anweisungen stehen */<br />
} /* der Block endet */<br />
<br />
return 0;<br />
} /* "main" endet */<br />
</pre><br />
<br />
'''Bemerkung:''' <br />
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen! <br />
<br />
=Datentypen=<br />
==Elementare Datentypen==<br />
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.<br />
<br />
;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!<br />
<br />
===int, char, short, long (ganze Zahlen)===<br />
In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen. <br />
<br />
Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann recht der Wertebereich von <tt>-2<sup>''b''-1</sup></tt> bis zu <tt>2<sup>''b''-1</sup>-1</tt>.<br />
<br />
Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2<sup>''b''</sup>-1</tt>, wenn der Typ ''b'' Bits breit ist.<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs<br />
|- <br />
| 8 || <tt>char</tt> <br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -128<br />0<br />
| align="right" | 127<br />255<br />
|- <br />
| 16 || <tt>short</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -32.768<br />0<br />
| align="right" | 32.767<br />65.535<br />
|- <br />
| 32 || <tt>long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -2.147.483.648<br />0<br />
| align="right" | 2.147.483.647<br />4.294.967.295<br />
|- <br />
| 64 || <tt>long long</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
| align="right" | -9.223.372.036.854.775.808<br />0<br />
| align="right" | 9.223.372.036.854.775.807<br />18.446.744.073.709.551.615<br />
|-<br />
|8, 16, 32, 64<br/><br />
| <tt>int</tt><br />
| <tt>signed</tt><br/><tt>unsigned</tt><br />
|plattform-/compilerabhängig<br />
|plattform-/compilerabhängig<br />
|}<br />
</center><br />
<br />
==== Boolean (Logische Variablen)====<br />
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.<br />
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.<br />
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert&nbsp;1 haben muß. Sie muß lediglich ungleich&nbsp;0 sein!<br />
<br />
====char (Zeichen)====<br />
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen. <br />
<br />
Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!<br />
<br />
===float, double (Gleitkommazahlen)===<br />
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. <br />
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.<br />
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.<br />
<br />
===void===<br />
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.<br />
<br />
==Zeiger==<br />
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''. <br />
<br />
Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein&nbsp;<tt>&</tt> voranstellt. Die Umkehrung davon &ndash; also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist &ndash; erledigt ein vorgestellter&nbsp;<tt>*</tt>. Der Operator &nbsp;<tt>*</tt> gibt also den ''Inhalt'' der Adresse.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int * zeiger;<br />
int zahl;<br />
<br />
zeiger = &zahl;<br />
*zeiger = 12;<br />
<br />
printf ("%d = %d", zahl, *zeiger);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der&nbsp;<tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:<br />
int * zeiger, zahl;<br />
<br />
Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator&nbsp;<tt>&</tt> von <tt>zahl</tt>:<br />
zeiger = &zahl; <br />
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>). <br />
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.<br />
<br />
==Zusammengesetzte Datentypen==<br />
===Arrays===<br />
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays &ndash; teilweise auch als ''Felder'' bezeichnet &ndash; zu verwenden.<br />
<br />
In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis </tt>Zahl_99</tt> arbeiten!<br />
<br />
'''Syntax:''' Datentyp Variablenname[Anzahl]<br />
<br />
Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für 3 Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes. <br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int i;<br />
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */<br />
<br />
for (i=0; i<10; i++)<br />
{<br />
printf ("Bitte Zahl %d eingeben: ", i);<br />
scanf ("%d", & zahlen[i]);<br />
printf ("\n");<br />
}<br />
printf ("Super!\n");<br />
<br />
for (i=0; i<10; i++) <br />
printf ("Zahl %d ist: %d\n", i, zahlen[i]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen:''' <br />
Zuerst wird ein 10 int-Variablen großes Array angelegt. <br />
In dieses wird nun der Reihe nach 10 Zahlen eingelesen. <br />
Anschließend werden alle 10 Zahlen ausgegeben. <br />
<br />
{{FarbigerRahmen|<br />
'''Merke:'''<br />
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!<br />
}}<br />
<br />
===Strings (Zeichenketten)===<br />
Ein String ist nicht sanderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.<br />
<br />
Die Definition eines Strings erfolgt also genauso wie bei Arrays:<br />
char string[21];<br />
<br />
Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert". <br />
<br />
Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.<br />
<br />
===Mehrdimensionale Arrays===<br />
Manchmal benötigen mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.<br />
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:<br />
<pre><br />
#include <stdio.h><br />
<br />
int main(void)<br />
{<br />
int x,y;<br />
int feld[3][5];<br />
<br />
for (x=0; x<3; x++) <br />
{<br />
for (y=0; y<5; y++)<br />
{<br />
printf ("Feldwert x: %d, y: %d ", x, y);<br />
scanf ("%d", & feld[x][y]);<br />
printf ("\n");<br />
}<br />
}<br />
<br />
for(x=0; x<3; x++) <br />
for (y=0; y<5; y++) <br />
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Erklärung:''' <br />
<br />
Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt. <br />
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>. <br />
Zum Schluß werden alle Werte noch einmal ausgegeben.<br />
<br />
===Strukturen===<br />
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden: <br />
<br />
<pre><br />
struct Person <br />
{<br />
int id;<br />
char vname[20], nname[20];<br />
char telnr[15];<br />
int alter;<br />
};<br />
</pre><br />
<br />
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein. <br />
Dann werden in dieser Struktur vier Komponenten angelege: drei Strings und zwei <tt>int</tt>. <br />
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach <br />
struct Person Variablenname;<br />
an. <br />
<br />
Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:<br />
<pre><br />
struct Person hubert, klaus;<br />
<br />
hubert.alter = 32;<br />
klaus.alter = hubert.alter + 1;<br />
</pre><br />
<br />
===Unions===<br />
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.<br />
<pre><br />
union Daten <br />
{<br />
int id;<br />
<br />
struct u_double<br />
{<br />
int id;<br />
double wert;<br />
};<br />
<br />
struct Person u_person;<br />
<br />
struct u_pointer<br />
{<br />
int id;<br />
union Daten * p1;<br />
union Daten * p2;<br />
};<br />
};<br />
<br />
union Daten data;<br />
</pre><br />
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_double</tt>, <tt>u_person</tt> und <tt>u_pointer</tt>. Die Große der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden.<br />
<br />
Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:<br />
<pre><br />
typedef union<br />
{<br />
unsigned long as_long;<br />
unsignen chat as_byte[4];<br />
} data32_t;<br />
</pre><br />
Dies überlagert einen <tt>unsigned long</tt> &ndash; also eine 32-Bit-Zahl &ndash; mit vier Bytes.<br />
<pre><br />
data32_t wert;<br />
<br />
wert.as_long = 0x12345678;<br />
wert.as_byte[0] = 0xab;<br />
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */<br />
</pre><br />
<br />
=Variablen=<br />
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.<br />
<br />
==Variablennamen==<br />
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.<br />
<br />
Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.<br />
==Anlegen von Variablen==<br />
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung! <br />
<pre><br />
int Zahl1, Zahl2;<br />
char Zeichen;<br />
<br />
int main (void)<br />
{<br />
float gleitZahl;<br />
/* Anweisungen */<br />
<br />
return 0;<br />
}<br />
</pre><br />
;Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].<br />
<br />
==Zuweisungen==<br />
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]]. <br />
<pre><br />
int main (void)<br />
{<br />
int zahl1, zahl2 = 12;<br />
char zeichen1 = 'A';<br />
<br />
zahl1 = 52;<br />
zeichen1 = zeichen1 + 1; <br />
<br />
return 0;<br />
}<br />
</pre><br />
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>). <br />
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen. <br />
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.<br />
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.<br />
<br />
==Zuweisungen bei float==<br />
Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt: <br />
floatVariable = 3.14;<br />
Zusätzlich kann eine Zehnerpotenz angegeben werden:<br />
floatVariable2 = -1.234E-6;<br />
Dadurch wird der erst Wert mit 10<sup><tt>-</tt>6</sup> multipliziert, der Wert der Variablen ist also <br />
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.<br />
<br />
==Zuweisungen bei logischen Variablen==<br />
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr". <br />
intVariable = !0; /* entspricht "wahr" */<br />
intVariable = 0; /* entspricht "unwahr" */<br />
<br />
==Vergleich von Variablen==<br />
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln: <br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|}<br />
</center><br />
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl. <br />
intVariable = zahl1 <= zahl2;<br />
das komplette Beispiel zeigt es deutlicher:<br />
<pre><br />
int i;<br />
int z1, z2;<br />
<br />
z1 = 5;<br />
z2 = 100;<br />
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */<br />
<br />
printf ("Ergebnis: %d\n", i);<br />
</pre><br />
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").<br />
<br />
==Konstanten==<br />
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:<br />
const ''datentyp'' name = value; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. <br />
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.<br />
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */<br />
<br />
Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit<br />
* ((float*) &PI) = 2;<br />
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.<br />
<br />
Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist<br />
void foo (const char * str, ...);<br />
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.<br />
<br />
Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:<br />
void foo (char * const str, ...);<br />
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>. Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim&nbsp;<tt>*</tt> auf: Steht das <tt>const</tt> links vom&nbsp;<tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides &ndash; also den Zeiger und sein Ziel &ndash; als konstant zu markieren.<br />
<br />
==Gültigkeitsbereich==<br />
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln: <br />
<br />
;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.<br />
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.<br />
<br />
==Speicherklassen==<br />
Jede Variable in C gehört zu einer bestimmten Speicherklasse<br />
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.<br />
;<tt>extern</tt>: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].<br />
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.<br />
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable &ndash; falls möglich &ndash; als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!<br />
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.<br />
<br />
=Ausdrücke=<br />
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.<br />
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.<br />
<br />
Einfache Beispiele für Ausdrücke sind also z.B.:<br />
1<br />
a<br />
'a'<br />
1 + a<br />
a == 1<br />
<br />
Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.<br />
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,<br />
und wei man damit neue Ausdrücke aufbauen kann.<br />
<br />
==Lvalues==<br />
<br />
Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.<br />
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.<br />
<br />
Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:<br />
a = 1;<br />
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie<br />
a+1 = 2;<br />
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":<br />
"ungültiger Wert in Zuweisung"<br />
<br />
Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante&nbsp;4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung&nbsp;<tt>*</tt> wird an die Adresse&nbsp;4 im Speicher eine&nbsp;3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.<br />
* ((unsigned int *) 4) = 3;<br />
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue<br />
<br />
==Logische (boolsche) Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a &amp;&amp; b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr<br />
|-<br />
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr<br />
|-<br />
|<tt>a == b</tt> || gleich<br />
|-<br />
|<tt>a != b</tt> || ungleich<br />
|-<br />
|<tt>a <= b</tt> || kleiner oder gleich<br />
|-<br />
|<tt>a < b</tt> || kleiner als<br />
|-<br />
|<tt>a >= b</tt> || glösser oder gleich<br />
|-<br />
|<tt>a > b</tt> || grösser als<br />
|-<br />
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa<br />
|}<br />
</center><br />
<br />
Eine interessante Eigenheit der Operatoren <tt>&amp;&amp;</tt> und <tt>||</tt> ist, dass<br />
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden<br />
dabei immer von links nach rechts ausgewertet.<br />
<br />
Beispiel:<br />
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */<br />
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */<br />
<br />
<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,<br />
die eine aufwändige Operation durchführt.<br />
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder<br />
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.<br />
<br />
Wo ist also der Unterschied?<br><br />
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,<br />
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.<br />
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte<br />
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.<br />
<br />
==Arithmetische Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a + b</tt> || Summe (Addition)<br />
|-<br />
|<tt>a - b</tt> || Differenz (Subtraktion)<br />
|-<br />
|<tt>a * b</tt> || Produkt (Multiplikation)<br />
|-<br />
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)<br />
|-<br />
|<tt>a % b</tt> || Rest bei Division (Modulo)<br />
|-<br />
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)<br />
|}<br />
</center><br />
==Bit-Operatoren==<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a & b</tt> || bitweise und (and)<br />
|-<br />
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)<br />
|-<br />
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)<br />
|-<br />
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)<br />
|}<br />
</center><br />
==Index-Operator bei Arrays==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a<br />
|}<br />
</center><br />
<br />
Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:<br />
<br />
# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein<br />
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)<br />
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!<br />
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung<br />
<br />
==Komponenten-Auswahl bei Structs und Unions==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a<br />
|}<br />
</center><br />
<br />
==Adress-Operator und Dereferenzierung==<br />
<br />
<center><br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!|Ausdruck ||Beschreibung<br />
|-<br />
|<tt>&amp;a</tt> || Speicheradresse der Variablen <tt>a</tt><br />
|-<br />
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht<br />
|-<br />
||<tt>a-&gt;b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht<br />
|}<br />
</center><br />
<br />
Der Adressoperator & kann auf Variablen angewendet werden und<br />
gibt die Startadresse der Variablen im Speicher zurück.<br />
<br />
Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält<br />
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der<br />
an dieser Adresse steht, wird der Operator * vorangestellt.<br />
<br />
Beispiel:<br />
<pre><br />
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */<br />
<br />
/* z ist ein Zeiger auf eine Integervariable und enthält somit<br />
die Speicheradresse einer Integervariablen<br />
*/<br />
int *z; <br />
<br />
/* Verwendung des Adressoperators... */<br />
z = &x; /* weise z die Speicheradresse von x zu */<br />
<br />
/* Verwendung der Dereferenzierung */<br />
/* erhöhe den Wert, der bei Adresse z steht um eins */<br />
*z = *z + 1;<br />
<br />
/* da z auf x zeigt, hat auch x jetzt den Wert 6 */<br />
</pre><br />
<br />
Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff<br />
auf ein Element eine abkürzende Schreibweise möglich:<br />
<br />
Statt <br />
(*strukturZeiger).element<br />
kann geschrieben werden<br />
strukturZeiger->element<br />
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch<br />
auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu<br />
einer Änderung '''irgendeiner''' Speicherstelle:<br />
<br />
<pre><br />
int *z; /* z ist ein Zeiger auf einen Integer */<br />
<br />
/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.<br />
z enthält irgendeine(!) Adresse<br />
*/<br />
<br />
/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */<br />
*z = *z + 1;<br />
</pre><br />
<br />
Viele C-Compiler (z.B. gcc) erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!<br />
}}<br />
<br />
==Cast-Operator==<br />
<br />
Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.<br />
<br />
Um zum Beispiel aus einem Float ein Integer zu machen:<br />
var = (int) 5.60;<br />
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.<br />
<br />
Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:<br />
int * addr;<br />
addr = (int*) 0x1234;<br />
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder<br />
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in<br />
eine Zahl oder umgekehrt zu wandeln:<br />
<br />
<pre><br />
#include <stdio.h><br />
int main(int argc, char ** argv)<br />
{<br />
char text[] = "5.6";<br />
int zahl = (int)text;<br />
<br />
printf("%d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator<br />
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.<br />
}}<br />
<br />
==Komma Operator==<br />
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.<br />
Die Auswertung erfolgt von links nach rechts.<br />
<br />
Solche Konstrukte sieht man manchmal in Abfragen wie<br />
FILE *file;<br />
if (file = fopen ("foo.exe", "r"), file != NULL)<br />
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,<br />
wenn <tt>file</tt> nicht der Nullpointer ist.<br />
<br />
==Zuweisungen und Operatoren mit Nebeneffekt==<br />
===Bedingte Zuweisung===<br />
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;<br />
<br />
<!--<br />
Kein ANSI-C<br />
--[[Benutzer:SprinterSB|SprinterSB]] 17:15, 29. Jun 2006 (CEST)<br />
==Blöcke==<br />
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.<br />
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks. <br />
Der Block muss un runden Klammern stehen:<br />
int sum;<br />
sum = ({<br />
int i, s = 0;<br />
for (i=1; i<= 100; i++)<br />
s += i;<br />
s;<br />
});<br />
<br />
Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc, <br />
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer<br />
Instruktion nicht machbar wäre:<br />
<pre><br />
#define PSTR(s) \<br />
({ \ <br />
static char __c[] PROGMEM = (s); \<br />
__c; \<br />
})<br />
</pre><br />
--><br />
<br />
==Reihenfolge der Auswertung==<br />
<br />
=Kontrollanweisungen=<br />
<br />
==Boolsche Logik==<br />
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird). <br />
<br />
b1= b2 && b3;<br />
<br />
<br />
Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).<br />
<br />
<br />
b1= b2 || b3;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.<br />
<br />
<br />
b1= !b2;<br />
<br />
<br />
Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".<br />
<br />
==<tt>if</tt>-Anweisung==<br />
Syntax: IF (Bedingung) Anweisung;<br />
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:<br />
<br />
[[bild:ifthenelse.png]]<br />
<br />
Und in C schreibt man:<br />
<pre><br />
if (Bedingung) /* WENN */<br />
{ /* DANN */<br />
Anweisung1;<br />
Anweisung2;<br />
...<br />
}<br />
else<br />
{ /* SONST */<br />
Anweisung3;<br />
Anweisung4;<br />
...<br />
}<br />
</pre><br />
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt. <br />
<br />
Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.<br />
<br />
{{FarbigerRahmen | <br />
'''Achtung!'''<br />
<br />
<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki><br />
<br />
<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki><br />
<br />
<br />
Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.<br />
}}<br />
<br />
==<tt>switch</tt>-Anweisung==<br />
Syntax: <br />
<pre><br />
switch(ausdruck) {<br />
case wert1:<br />
Anweisungen1...<br />
case wert2:<br />
Anweisungen2...<br />
case wert3:<br />
Anweisungen3...<br />
...<br />
default:<br />
Anweisungen4...<br />
}<br />
</pre><br />
<br />
Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter<br />
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der<br />
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt><br />
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.<br />
<br />
<b>Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines<br />
<tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!</b><br />
<br />
Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.<br />
Der <tt>default</tt>-Abschnitt ist optional, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,<br />
wenn er verwendet wird.<br />
<br />
<br />
==Schleifen==<br />
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.<br> <br />
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird. <br />
<br />
===<tt>while</tt>-Schleife===<br />
'''Syntax:''' while (Bedingung) { Anweisung; }<br />
<br />
Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block! <br />
<br />
<pre><br />
Zahl1=0;<br />
while (Zahl1<3)<br />
{<br />
Zahl1=Zahl1+1;<br />
Zahl2=Zahl2*2;<br />
}<br />
</pre><br />
<br />
In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.<br />
===<tt>do</tt>-<tt>while</tt>-Schleife===<br />
'''Syntax:''' do { Anweisung; }while (Bedingung);<br />
<br />
Die DO WHILE-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird <br />
<br />
<pre><br />
int i=2;<br />
do <br />
{<br />
i = i*i; /* i quadrieren */<br />
printf ("i = %d\n", i);<br />
}<br />
while (i < 20);<br />
</pre><br />
<br />
Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.<br />
<br />
===<tt>for</tt>-Schleife===<br />
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }<br />
<br />
Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.<br />
<br />
Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.<br />
<br />
Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet. <br />
<br />
<pre><br />
int lauf;<br />
int summe = 0;<br />
<br />
for (lauf = 1; lauf <= 10; lauf = lauf+2 ) <br />
{<br />
summe = summe + lauf;<br />
}<br />
</pre><br />
Das Äquivalent als <tt>while</tt>-Schleife:<br />
<pre><br />
int lauf = 1; /* Anfangswerte */<br />
int summe = 0;<br />
<br />
while (lauf <= 10) /* Bedingung */<br />
{<br />
summe = summe + lauf;<br />
lauf += 2; /* Inkrement */<br />
}<br />
</pre><br />
<br />
<br />
In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.<br />
<br />
'''Erklärung:''' <br />
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. <br />
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. <br />
<tt>lauf = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um&nbsp;2 erhöht wird.<br />
<br />
=Ein- und Ausgabe=<br />
<br />
==Bildschirm-Ausgabe==<br />
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.<br />
<br />
Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, </tt>char</tt>, <tt>double</tt>...) sein! <br />
<pre><br />
#include <stdio.h><br />
<br />
int main (void)<br />
{<br />
int zahl1 = 12;<br />
char zeichen1 = 'A';<br />
<br />
printf ("Das ist Text, und er wird als solcher ausgegeben. \n");<br />
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);<br />
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile. <br />
<br />
Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus. <br />
<br />
In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert. <br />
<br />
Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen! <br />
<br />
==Tastatur-Eingabe==<br />
<br />
Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.<br />
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>: <br />
<br />
<pre><br />
int zahl1;<br />
char zeichen1;<br />
<br />
printf ("Bitte geben Sie eine Zahl ein: ");<br />
scanf ("%d", &zahl1);<br />
printf ("Geben Sie einen Zeichen ein: ");<br />
scanf ("%c", &zeichen1);<br />
</pre><br />
<br />
Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.<br />
<br />
Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!<br />
<br />
Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference"). <br />
<br />
<br />
=Allgemeines zu Unterprogrammen=<br />
Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen.<br />
Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen: <br />
<br />
==Funktionen==<br />
'''Syntax:''' Rückgabe-Typ Name(Parameterliste);<br />
<br />
Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln: <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
int hoch2 (int param1)<br />
{<br />
int zahl;<br />
zahl = param1 * param1;<br />
return zahl;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl1, ergebnis;<br />
<br />
printf ("Bitte Zahl eingeben: ");<br />
scanf ("%d",&zahl1);<br />
<br />
ergebnis = hoch2 (zahl1);<br />
<br />
printf ("%d hoch 2 = %d\n",zahl1, ergebnis);<br />
printf ("5 hoch 2 = %d\n", hoch2(5));<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. <br />
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. <br />
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.<br />
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. <br />
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert. <br />
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an<br />
variable = Funktion (Parameter);<br />
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile). <br />
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.<br />
<br />
==Prozedur==<br />
'''Syntax:''' <tt>void Name (Parameterliste)</tt><br />
<br />
Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp <tt>void</tt>, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede: <br />
<br />
Als Rückgabe-Datentyp wird <tt>void</tt> angegeben. <br />
Einer Variablen kann daher nicht der Rückgabewert einer <tt>void</tt>-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int param1)<br />
{<br />
printf ("Der Wert der Variablen ist: %d\n", param1);<br />
}<br />
<br />
int main(void)<br />
{<br />
int zahl1 = 4;<br />
<br />
ausgeben (23);<br />
ausgeben (zahl1);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Bemerkungen zum Programm:''' <br />
Durch den Befehl "<tt>ausgeben(23)</tt>" wird die Prozedur "<tt>ausgeben</tt>" mit dem Parameter <tt>23</tt> aufgerufen. <tt>param1</tt> hat also den Wert <tt>23</tt>. Die einzige Anweisung innerhalb der Prozedur ist <tt>printf</tt>, was nun ausgeführt wird. <br />
Der zweite Aufruf von <tt>ausgeben</tt> erfolgt mit dem Parameter <tt>zahl1</tt>, also wird <tt>param1</tt> der Wert 4 zugewiesen. Dieser wird nun wieder mittels <tt>printf</tt> ausgeben. <br />
<br />
Unterprogramme ohne Parameter<br />
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur <tt>void</tt> stehen. Das <tt>void</tt> bedeutet "die Funktion erhält keine Parameter". "<tt>void main (void)</tt>" bedeutet also: "Erstelle ein Unterprogramm Namens <tt>main</tt>, das keinen Rückgabewert und keine Parameter hat".<br />
<br />
{{FarbigerRahmen |<br />
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:<br />
foo();<br />
}}<br />
<br />
==Prototypen==<br />
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?<br />
Um dies zu erreichen, gibt es zwei Möglichkeiten: <br />
<br />
Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! <br />
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. <br />
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt&nbsp;<tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). <br />
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.<br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void ausgeben (int zahl); /* Der Prototyp */<br />
<br />
int main (void)<br />
{<br />
ausgeben (12);<br />
<br />
return 0;<br />
}<br />
<br />
void ausgeben (int zahl) /* Die eigentliche Prozedur */<br />
{<br />
printf ("Ausgabe: %d\n", zahl);<br />
}<br />
</pre><br />
<br />
==Parameterübergabe==<br />
<br />
Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.<br />
Das hat folgende Auswirkungen:<br />
<br />
# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!<br />
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger | Zeiger]] übergeben werden.<br />
# Werden [[#Strukturen | Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.<br />
<br />
<br />
Beispiele:<br />
<pre><br />
void erhoehe (int x)<br />
{<br />
x = x + 1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int a = 0;<br />
erhoehe(a);<br />
/* a ist immer noch 0 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.<br />
<br />
<pre><br />
void erhoehe (int *x)<br />
{<br />
/* erhöhe den Wert an der Adresse x um eins */<br />
*x = *x + 1;<br />
}<br />
<br />
int main(void)<br />
{<br />
int a = 0;<br />
erhoehe (&a);<br />
/* a ist jetzt 1 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&amp;</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die<br />
Adresse des Originals <tt>a</tt> und kann direkt mit dem Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.<br />
<br />
<br />
'''Besonderheit bei Feldern'''<br />
<br />
Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines<br />
Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.<br />
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf<br />
den Originaldaten arbeiten und diese verändern.<br />
<br />
Beispiel:<br />
<pre><br />
void erhoehe (int x[])<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
<br />
Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:<br />
<br />
<pre><br />
/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */<br />
void erhoehe (int *x)<br />
{<br />
x[0] = x[0] + 1;<br />
x[1] = x[1] + 3;<br />
x[2] = x[2] + 5;<br />
}<br />
<br />
int main(int argc, char **argv)<br />
{<br />
int a[] = {10, 20, 30};<br />
<br />
erhoehe (a);<br />
<br />
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */<br />
}<br />
</pre><br />
<br />
{{FarbigerRahmen |<br />
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.<br />
}}<br />
<br />
=Standard-Funktionen=<br />
<br />
==strcpy==<br />
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren! <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri1[21], eingabe[21];<br />
<br />
strcpy (stri1, "hallo");<br />
<br />
printf ("Der 1. String: %s\n", stri1);<br />
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");<br />
scanf ("%s", eingabe);<br />
strcpy (stri1, eingabe);<br />
printf ("\n%s = %s", stri1, eingabe);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
'''Hinweis:''' <br />
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&amp;</tt> bei <tt>scanf</tt> angeben!<br />
<br />
'''Erklärung:''' <br />
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen. <br />
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. <br />
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings. <br />
Sie werden gebeten, eine String einzugeben. <br />
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert. <br />
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.<br />
<br />
==strlen==<br />
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern. <br />
<br />
<pre><br />
#include <stdio.h><br />
#include <string.h><br />
<br />
int main (void)<br />
{<br />
char stri[21];<br />
<br />
strcpy (stri, "hallo");<br />
printf ("Der String ist %d Zeichen lang", strlen (stri));<br />
}<br />
</pre><br />
<br />
Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc. <br />
<br />
<br />
<br />
===Zeiger als Parameter===<br />
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.<br />
Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable"). <br />
<br />
<pre><br />
#include <stdio.h><br />
<br />
void erhoehe (int *zeiger)<br />
{<br />
*zeiger = *zeiger+1;<br />
}<br />
<br />
int main (void)<br />
{<br />
int zahl;<br />
<br />
printf ("Zahl eingeben: ");<br />
scanf ("%d", &zahl);<br />
erhoehe (&zahl);<br />
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
==Parameter von <tt>main</tt>==<br />
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen. <br />
<pre><br />
int main (int argc, char *argv[], char* environ[])<br />
</pre><br />
<br />
Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge&nbsp;0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.<br />
<pre><br />
#include <stdio.h><br />
#include <stdlib.h><br />
<br />
int main (int argc, char *argv[], char * environ[])<br />
{<br />
int i;<br />
<br />
printf ("Es wurden %d Parameter angegeben", argc);<br />
<br />
for (i=0; i < argc; i++) <br />
printf ("Parameter %d: %s\n", i, argv[i]);<br />
<br />
for (i = 0; environ[i] != NULL; ++i) <br />
printf ("environ[%d] = %s\n", i, environ[i]);<br />
}<br />
</pre><br />
<br />
;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement &ndash; wie in C üblich &ndash; das Element <tt><tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen! <br />
<br />
=Liste der Schlüsselworte=<br />
<br />
* [[#Speicherklassen|auto]]<br />
* break<br />
* [[#Elementare Datentypen|double]]<br />
* [[#Elementare Datentypen|char]]<br />
* case<br />
* [[#Konstanten|const]]<br />
* continue<br />
* default<br />
* do<br />
* else<br />
* enum<br />
* [[#Speicherklassen|extern]]<br />
* [[#Elementare Datentypen|float]]<br />
* for<br />
* goto<br />
* if<br />
* [[##Elementare Datentypen|int]]<br />
* [[#Elementare Datentypen|long]]<br />
* return<br />
* [[#Speicherklassen|register]]<br />
* [[#Elementare Datentypen|short]]<br />
* signed<br />
* sizeof<br />
* [[#Speicherklassen|static]]<br />
* [[#Strukturen|struct]]<br />
* switch<br />
* typedef<br />
* [[#Unions|union]]<br />
* unsigned<br />
* [[#Elementare Datentypen|void]]<br />
* volatile<br />
* while<br />
<br />
Baustelle<br />
<br />
=Liste der Operatoren=<br />
<br />
Baustelle<br />
<br />
{| {{Blauetabelle}}<br />
|- {{Hintergrund1}}<br />
!| Operator || Bedeutung || Nebeneffekte<br />
|-<br />
| <tt>==</tt> || ist gleich <br />
|-<br />
| <tt>!=</tt> || ist nicht gleich <br />
|-<br />
| <tt>&lt;</tt> || ist kleiner <br />
|-<br />
| <tt>&lt;=</tt> || ist kleiner oder gleich <br />
|-<br />
| <tt>&gt;</tt> || ist größer <br />
|-<br />
| <tt>&gt;=</tt> || ist größer oder gleich <br />
|-<br />
| <tt>&amp;</tt> || <br />
|-<br />
| <tt>=</tt> || <br />
|-<br />
| <tt>+=</tt> || <br />
|-<br />
| <tt>-=</tt> || <br />
|-<br />
| <tt>*=</tt> || <br />
|-<br />
| <tt>/=</tt> || <br />
|-<br />
| <tt>^=</tt> || <br />
|-<br />
| <tt>&=</tt> || <br />
|-<br />
| <tt>|=</tt> || <br />
|-<br />
| <tt>++</tt> || <br />
|-<br />
| <tt>--</tt> || <br />
|-<br />
| <tt>&&</tt> || <br />
|-<br />
| <tt>||</tt> || <br />
|-<br />
| <tt>~</tt> || <br />
|-<br />
| <tt>!</tt> || <br />
|-<br />
| <tt>(<font color="blue"><Type></font>) <font color="blue"><Ausdruck></font></tt> || <br />
|-<br />
| <tt>+</tt> || <br />
|-<br />
| <tt>-</tt> || <br />
|-<br />
| <tt>*</tt> || <br />
|-<br />
| <tt>/</tt> || <br />
|-<br />
| <tt>%</tt> || <br />
|-<br />
| <tt>%=</tt> || <br />
|-<br />
| <tt>? : </tt> || <br />
|-<br />
| <tt>.</tt> || <br />
|-<br />
| <tt>-></tt> || <br />
|}<br />
<br />
<br />
'''Autoren'''<br />
* Plasma<br />
* Bernd<br />
* [[Benutzer:SprinterSB|SprinterSB]]<br />
<br />
'''Quellen:'''<br />
* Kernighan und Ritchie - Buch<br />
* Christian Wirth , C Tutorial<br />
* Prof. Dr. J. Dankert Ausführungen<br />
<br />
=Siehe auch=<br />
* [[avr-gcc]]<br />
* [[Compiler]]<br />
* [[WinAVR]]<br />
* [[Fallstricke bei der C-Programmierung]]<br />
<br />
=Weblinks=<br />
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]<br />
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]<br />
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]<br />
<br />
[[Kategorie:Quellcode C|!]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Kategorie:Quellcode_C&diff=8114Kategorie:Quellcode C2006-07-05T09:00:56Z<p>Roberto: </p>
<hr />
<div>In dieser Kategorie finden sich dokumentierte Programmbeispiele in der Programmiersprache C. <br />
Die Beispiele sind &ndash; sofern nicht anders angegeben &ndash; für den freien C/C++-Compiler [[avr-gcc]] Version 3.x. <br />
<br />
{{FarbigerRahmen|<br />
* Siehe auch die [[avr-gcc#Inkompatibilität|Hinweise zu Inkompatibilitäten von avr-gcc]].<br />
* Manche [[make]]file-Generatoren lieben es, unaufgefordert irgendwelche Compiler-Optionen zu aktivieren, welche die Semantik (Bedeutung) der C-Quelle ändern. Beliebt ist etwa der Schalter, <tt>char</tt> standardmässig auf <tt>unsigned</tt> zu setzen, wahrscheinlich weil manche faule Entwickler selbiger Tools dadurch das Tippseln einiger Buchstaben erspart blieb. Wer seinen Compiler dergestalt verbiegt, darf nicht erstaunt sein, wenn Beispiel-Code aus dem Netz nicht funktioniert. Die Beispielcodes hier in {{SITENAME}} tragen dieser Unart in gewissem Maße Rechnung, jedoch ist niemandem &ndash; vor allem dem Einsteiger nicht &ndash; damit gedient, alle möglichen und unmöglichen Schalterstellungen aus den Quellen herauszuparametrisieren. Der geneigte Anwender entsprechender Generatoren ist daher gut damit beraten, die C-Semantik beim Standard zu belassen.<br />
}}</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Diskussion:Codevergleich_AVR-Compiler&diff=6770Diskussion:Codevergleich AVR-Compiler2006-04-06T20:31:48Z<p>Roberto: </p>
<hr />
<div>Hallo Sprinter (schreibe mal hier)<br />
<br />
In Formeln bin ich sehr schlecht, aber was hälst DU davon, wenn man dazu fixe Werte für die Variablen verwendet, einen Einheitlichen Prozessor (z.B. den Mega8) und einen Gleichbeleibenden Quarz.<br />
Dann könnte man die Codes auch untereinander in der Ausführungszeit und dem Speicherverbrauch vergleichen..?<br />
Mann müsste dann aber auch den kompletten Code aufzeigen...<br />
(für C alle Libs..)--[[Benutzer:Roberto|Roberto]] 22:31, 6. Apr 2006 (CEST)</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6676SMD2006-03-31T19:05:07Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
<br />
* [http://de.wikipedia.org/wiki/Surface_Mounted_Device SMD und die Abmessungen im WIKI]<br />
* [http://www.elv-downloads.de/downloads/journal/smd-anleitung.pdf Beschreibung von ELV]<br />
<br />
* [http://thomaspfeifer.net/index2.htm unter Trickkiste und AVR Projekte,vieles um SMD löten/entlöten (Revlow Ofen selbstbau u.s.w.)]<br />
* [http://www.mikrocontroller.net/articles/SMD_L%F6ten SMD löten (Beschreibung von mikronkontroller.net) ]<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6671SMD2006-03-31T07:54:31Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
<br />
* [http://de.wikipedia.org/wiki/Surface_Mounted_Device SMD im WIKI]<br />
* [http://www.elv-downloads.de/downloads/journal/smd-anleitung.pdf Beschreibung von ELV]<br />
<br />
* [http://thomaspfeifer.net/index2.htm unter Trickkiste und AVR Projekte,vieles um SMD löten/entlöten (Revlow Ofen selbstbau u.s.w.)]<br />
* [http://www.mikrocontroller.net/articles/SMD_L%F6ten SMD löten (Beschreibung von mikronkontroller.net) ]<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6670SMD2006-03-31T07:39:46Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
<br />
* [http://de.wikipedia.org/wiki/Surface_Mounted_Device SMD im WIKI]<br />
* [http://thomaspfeifer.net/index2.htm unter Trickkiste und AVR Projekte,vieles um SMD löten/entlöten (Revlow Ofen selbstbau u.s.w.)]<br />
* [http://www.mikrocontroller.net/articles/SMD_L%F6ten SMD löten (Beschreibung von mikronkontroller.net) ]<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6669SMD2006-03-31T07:29:09Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
<br />
* [http://de.wikipedia.org/wiki/Surface_Mounted_Device SMD im WIKI]<br />
* [http://thomaspfeifer.net/index2.htm unter Trickkiste und AVR Projekte,vieles um SMD löten/entlöten (Revlow Ofen selbstbau u.s.w.)]<br />
<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6668SMD2006-03-31T07:27:50Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
<br />
* [http://de.wikipedia.org/wiki/Surface_Mounted_Device SMD im WIKI]<br />
* [http://thomaspfeifer.net/index2.htm unter Trickkiste,vieles um SMD löten/entlöten (Revlow Ofen selbstbau u.s.w.)]<br />
<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6667SMD2006-03-31T07:26:58Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
<br />
* [http://de.wikipedia.org/wiki/Surface_Mounted_Device SMD im WIKI]<br />
* [http://thomaspfeifer.net/index2.htm vieles um SMD löten/entlöten (Revlow Ofen selbstbau u.s.w.)]<br />
<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6666SMD2006-03-31T07:25:58Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
<br />
* [http://de.wikipedia.org/wiki/Surface_Mounted_Device SMD im WIKI]<br />
* [http://thomaspfeifer.net/index2.htm vieles um SMD löten (Revlow u.s.w.)]<br />
<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6665SMD2006-03-31T07:24:37Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
<br />
* [http://de.wikipedia.org/wiki/Surface_Mounted_Device/ SMD im WIKI]<br />
* [http://thomaspfeifer.net/index2.htm/ Vieles um SMD löten (Revlow u.s.w.)]<br />
<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6664SMD2006-03-31T07:10:35Z<p>Roberto: /* Weblinks */</p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
<br />
==Weblinks==<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=SMD&diff=6663SMD2006-03-31T07:09:52Z<p>Roberto: </p>
<hr />
<div>==Was sind SMD-Bauteile?==<br />
[[Bild:smdbauteile.jpg|right|SMD-Bauteile auf einer Platine]]<br />
Im Gegensatz zur "konventionellen" Durchsteck-Technik werden SMD-Bauteile (vom engl. "Surface Mounted Devices") auf der Platinenoberfläche (surface) aufgebracht und verlötet, ohne die Leiterplatte zur Befestigung zusätzlich durchbohren zu müssen. Diese Technologie wird auch als SMT bezeichnet, vom englischen "Surface Mount Technology".<br />
<br />
Im Zuge dieser "drahtlosen" Technologie werden die bislang im sogenannten "Schwallbad" mit den Drahtbeinen an der Platinenunterseite verlöteten "konventionellen" Steck-Bauteile mehr und mehr durch die wesentlich temperaturresistenteren SMD-Komponenten ersetzt. <br />
Während letztere kurzzeitig problemlos Temperaturen von bis zu 240 Grad Celcius verkraften können, ohne Schade zu nehmen, liegt die mögliche Temperaturbelastung bei den bedrahteten Bauteilen in der Regel deutlich niedriger.<br />
Zudem gelten die "neuen" SMD-Komponenten aber auch als zuverlässiger, was der Qualität der gesamten Baugruppe entscheidend zugute kommt, und sind darüberhinaus kostengünstiger und schneller zu verarbeiten.<br />
Durch den Wegfall eines kompletten Arbeitsschrittes aufgrund fehlender Bohrungen bei reinen SMD-Bestückungen und kürzerer Bestückungs- und Lötzeiten enstehen nicht nur signifikante Einsparungspotentiale. Bei konsequenter Nutzung der SMD-Technologie werden zudem erheblich höhere Packungsdichten auf der Platine möglich und damit die im allgemeinen angestrebte oder sogar notwendige Miniaturisierung des Gesamtgehäuses erst möglich.<br />
<br />
<br />
Bei den Hobby-Elektronikern sind SMD-Bauteile relativ wenig verbreitet. Dies liegt vor allem daran, dass die Bauteile wirklich winzig sind und demnach die Kontaktabstände oft unter 1 mm liegen. <br />
Das Löten von SMD Bausteinen ist dadurch wesentlich schwieriger als bei herkömmlichen Bauelementen. Noch schwieriger ist das Auslöten von defekten SMD Bauteilen, hier haben nur noch Profis Chancen. Dem Elektronik-Einsteiger können SMD-Bauteile daher weniger empfohlen werden.<br />
<br />
<br />
[[Bild:smd-dip-atmega32.png|thumb|300px|left|Grössenvergleich zwischen SMD und DIP]]<br />
<br />
<br />
<br />
==Weblinks==<br />
* [http://stshome.de/elektronik/smd-loeten/ SMD-Löten]<br />
* [http://www.bimbel.de/artikel/artikel-17.html Tips SMD Löten]<br />
* [http://www-user.tu-chemnitz.de/~heha/bastelecke/Monitor%20reparieren/loeten.htm Tips zum Löten und Entlöten TU-Chemnitz]<br />
<br />
<br />
[[Kategorie:Elektronik]]<br />
[[Kategorie:Grundlagen]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=6555Bascom und I2C EEprom2006-03-19T23:07:25Z<p>Roberto: /* Beispiel für EEprom 24C16 */</p>
<hr />
<div>== Ansteuern vom I2C EEproms mit Bascom ==<br />
<br />
Der Artikel demonstriert wie man EEPROM Speicherbausteine unter Bascom über den [[I2C]]-Bus anspricht.<br />
<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständnis werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm könnte man aber auch eine Sub-Routine deklarieren, die dann den Schreib/Lesevorgang abwickelt.<br />
<br />
(Eine Sub-Routine braucht aber ca. um die 30Byte pro Aufruf mehr an Speicher, als ein Gosub aufruf. Ich persöhnlich bleibe deshalb doch lieber bei den Gosub's.)<br />
<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in High und Low Adressbereich trennen.<br />
(Zuerst High-Adressberreich schreiben und dann Low-Adressbereich) <br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte 1 'sende Speicheradresse High<br />
I2cwbyte B 'sende Speicheradresse Low<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== High/Low Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
==Weblinks==<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661 Roboternetz-Thread]<br />
* http://www.eseo.de/i2c.htm<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5780Bascom und I2C EEprom2006-02-02T14:14:30Z<p>Roberto: </p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
Der Artikel demonstriert wie man EEPROM Speicherbausteine unter Bascom über den [[I2C]]-Bus anspricht.<br />
<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in High und Low Adressbereich trennen.<br />
(Zuerst High-Adressberreich schreiben und dann Low-Adressbereich) <br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte 1 'sende Speicheradresse High<br />
I2cwbyte B 'sende Speicheradresse Low<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== High/Low Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
==Weblinks==<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661 Roboternetz-Thread]<br />
* http://www.eseo.de/i2c.htm<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5779Bascom und I2C EEprom2006-02-02T14:09:25Z<p>Roberto: /* Low/High Adressbereich mit Overlay leicht ansprechen */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
Der Artikel demonstriert wie man EEPROM Speicherbausteine unter Bascom über den [[I2C]]-Bus anspricht.<br />
<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== High/Low Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
==Weblinks==<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661 Roboternetz-Thread]<br />
* http://www.eseo.de/i2c.htm<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Benutzer_Diskussion:Roberto&diff=5751Benutzer Diskussion:Roberto2006-01-31T23:54:15Z<p>Roberto: /* Bascom und Counter */</p>
<hr />
<div>Hi,<br />
du machst feine Artikel!<br />
Aber bitte nicht jede Zeile mit <nowiki><BR></nowiki> umbrechen. Der Text sollte gewöhnlich fließend eingegeben werden, nur bei Absätzen entweder Leerzeilen oder halt <nowiki><BR></nowiki> einfügen. Nur so ist sichergestellt das der Artikel in allen Auflösungen nett aussieht. <br />
Wenn Du willst kannst du die Bilder mittig anzeigen lassen, ich hab es bei ersten bild im pwm Artikel mal gemacht.<br />
--[[Benutzer:Frank|Frank]] 14:15, 14. Jan 2006 (CET)<br />
<br />
Noch eine Bitte, bei Artikel nicht die eigene Homepage drunter schreiben, außer es gehört zum Thema (dann aber unter Weblinks). Also nur den BenutzerNamen. Persönliche Angaben wie Homepage kannst du ja auf deiner Benutzerseite angeben. Ich habs mal probehalber mal für dich gemacht.<br />
<br />
hier [[Benutzer:Roberto|Roberto]]<br />
<br />
Hallo Frank.<br />
Ganz ist mir das mir den Diskusions sachen nicht klar.<br />
Hoffe ich schreibe hier jetzt richtig rein ?!<br />
<br />
Wenn ich ohne Umbruch mache, steht ja alles in einer Wurst ?<br />
Das schaut ja nach nix aus.<br />
Was macht es den eigentlich, wenn ich mehr BR's verwende ??<br />
--[[Benutzer:Roberto|Roberto]] 17:10, 14. Jan 2006 (CET)<br />
<br />
<br />
Ja du schreibst hier schon richtig! Zu jedem Artikel gibts eine Diskussionsseite um Sachen zu klären. Das ist deine private Diskussionsseite!<br />
Umbruch muss man weglassen da ja jeder andere Bildschirmbreiten besitzt. Natürlich kannst du bei Absätzen etc. einen Umbruch oder eine Leerzeile einfügen. Nur nicht in jeder Zeile. Am besten schaust du dir immer andere Artikel mit ÄNDERN an.<br />
--[[Benutzer:Frank|Frank]] 19:55, 14. Jan 2006 (CET)<br />
<br />
----<br />
<br />
Hallo Frank.<br />
Bisschen umständlich das ganze mit den Diskussionen...<br />
Da sieht man schlecht was jeder schreibt.<br />
Bei eMail kann man zu jedem Kommentar anworten und man sieht trotzdem, was jeder geschrieben hat.<br />
Aber egal.. Muss wohl damit leben ;-)<br />
<br />
Habe inzwischen alle BR gelöscht..<br />
Geht eigentlich so auch , nur halt mehr in einer Wurst...<br />
<br />
Ein paar Fragen hätte ich noch !!<br />
<br />
*Hast Du meine eMail bekommen wegen dem Thema Bascom ? (wohin u.s.w.)<br />
<br />
*Wie kann ich meine Beiträge in den Berreich Software ablegen, oder kann das nur ein Admin. ?<br />
<br />
* Bei "Bascom interupts", könntest Du bitte das "Interrupt" gross schreiben ?<br />
(kann das leider nicht ändern)<br />
<br />
* Wie kann ich meine eigenen Bilder löschen ???<br />
Habe da eines , zu grosses , hoch geladen und bei einem ist das Copyright falsch...<br />
<br />
* Wenn ich in zukunft eine Frage an dich habe, soll ich dann hier schreiben oder per eMAil ?<br />
<br />
* kann diese Diskusion dann eigentlich jeder lesen ?<br />
<br />
Ich glaube, einstweilen wären das alle Fragen ;-) :-)<br />
--[[Benutzer:Roberto|Roberto]] 21:31, 14. Jan 2006 (CET)<br />
<br />
<br />
----<br />
Hallo<br />
<br />
'''Zu deinen Fragen:'''<br />
<br />
* Mail hab ich keine bekommen. Musst du nochmal an webmaster... senden.<br />
* Ob du Bilder löschen kannst weiss ich nicht genau, zumindets Updaten müsstest du diese können. Einfach mal draufklicken dann solltest du Menüpunkt darunter finden. oder über Bilderliste oben im Menü.<br />
Zu große Bilder entweder updaten oder einfach verkleinern bei der Darstellung. Schau dazu mal in die Editierhilfe oder auch dir einfach mit ÄNDERN einige Artikel an wo kleinere Bilder zu sehen sind. Auf der Testseite ist glaub auch ein Beispiel. Wenn es ganz weg soll, kannst du einen Löschantrag einbauen. Schau dazu auch mal in die Hilfe, ist ganz leicht. Ein Mod oder ich löschen es dann. (siehe [[Hilfe:FAQ]])<br />
* Fragen kannst du im Forum posten (wenns eilig ist und für andere auch interessant ist), in der Artikeldiskussion (wenns zum Artikel passt) oder ne Mail.<br />
* Diskussionen kann jeder lesen, das ist bei Artikeldiskussionen ja immer Vorteilhaft<br />
* Man kann nichts in einer bestimmten Kategorie ablegen. Man teilt den Artikels durch den kategorie Befehl eine Kategorie zu. Bei deinen Artikeln hab ich das unten schon mehrfach gemacht. Dadurch sollte der Artikel dann in den passenden Rubriken erscheinen. Steht aber auch in der Editierhilfe [[RN-Wissen:Editierhilfe]]<br />
* Ach so, das umbenennen von Artikeln geht nicht so einfach, können eigentlich nur Moderatoren. Ich habs mal gemacht: [[Bascom Interrupts]]<br />
<br />
Hat man erst mal alles raus ist es eigentlich alles recht einfach. <br />
<br />
Gruß Frank<br />
<br />
== Bascom und Counter ==<br />
<br />
Hallo,<br />
mir ist aufgefallen das der Artikel [[Bascom und Counter]] seit längerem auf<br />
Status Artikelbaustelle steht. <br />
Solltest du den Artikel erstmal nicht fertig machen wollen, vielleicht aus Zeitmangel, dann gib bescheid. Wir könnten ihn dann erstmal löschen (ist ja noch leer). Artikelbaustellen sollten nicht zu lange offen sein.<br />
<br />
Gruß<br />
<br />
--[[Benutzer:Frank|Frank]] 12:52, 31. Jan 2006 (CET)<br />
<br />
<br />
Hallo Frank<br />
<br />
Ja, ich komme ledier derzeit nicht dazu...<br />
Ist vielleicht doch besser den einstweilen zu löschen..<br />
<br />
Was anderes..<br />
Es gibt ja inzwischen schon ein paar Artikel zu Bascom (timer,Verzweigungen u.s.w..) <br />
Vielleicht könnte man das irgendwo zusammenlegen... ? Unter Bascom oder so ?<br />
Oder unter Software/Bascom vielleicht ?!<br />
<br />
Was meinst Du dazu ?!<br />
--[[Benutzer:Roberto|Roberto]] 20:47, 31. Jan 2006 (CET)<br />
<br />
<br />
Ok, hab die Seite erst mal gelöscht. Kannst ja jederzeit wieder neu einfügen.<br />
Nun zusammenfassen würde ich´s momentan eigentlich nicht. Sind ja recht unterschiedliche Themen, die könnte man sicher noch ausbauen und weiter mit Beispielen versehen. Ist eventuell für einen Artikel am Ende zu lang.<br />
--[[Benutzer:Frank|Frank]] 22:42, 31. Jan 2006 (CET)<br />
<br />
<br />
OK :-)<br />
<br />
Was ist eigentlich unter Software das "B cont." ??<br />
<br />
Da sind ein paar Artikel drinnen, die eigentlich auch zu "B" gehören.<br />
(Bascom und Timer, Bascom und PWM...)<br />
--[[Benutzer:Roberto|Roberto]] 00:54, 1. Feb 2006 (CET)</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Benutzer_Diskussion:Roberto&diff=5738Benutzer Diskussion:Roberto2006-01-31T19:48:38Z<p>Roberto: /* Bascom und Counter */</p>
<hr />
<div>Hi,<br />
du machst feine Artikel!<br />
Aber bitte nicht jede Zeile mit <nowiki><BR></nowiki> umbrechen. Der Text sollte gewöhnlich fließend eingegeben werden, nur bei Absätzen entweder Leerzeilen oder halt <nowiki><BR></nowiki> einfügen. Nur so ist sichergestellt das der Artikel in allen Auflösungen nett aussieht. <br />
Wenn Du willst kannst du die Bilder mittig anzeigen lassen, ich hab es bei ersten bild im pwm Artikel mal gemacht.<br />
--[[Benutzer:Frank|Frank]] 14:15, 14. Jan 2006 (CET)<br />
<br />
Noch eine Bitte, bei Artikel nicht die eigene Homepage drunter schreiben, außer es gehört zum Thema (dann aber unter Weblinks). Also nur den BenutzerNamen. Persönliche Angaben wie Homepage kannst du ja auf deiner Benutzerseite angeben. Ich habs mal probehalber mal für dich gemacht.<br />
<br />
hier [[Benutzer:Roberto|Roberto]]<br />
<br />
Hallo Frank.<br />
Ganz ist mir das mir den Diskusions sachen nicht klar.<br />
Hoffe ich schreibe hier jetzt richtig rein ?!<br />
<br />
Wenn ich ohne Umbruch mache, steht ja alles in einer Wurst ?<br />
Das schaut ja nach nix aus.<br />
Was macht es den eigentlich, wenn ich mehr BR's verwende ??<br />
--[[Benutzer:Roberto|Roberto]] 17:10, 14. Jan 2006 (CET)<br />
<br />
<br />
Ja du schreibst hier schon richtig! Zu jedem Artikel gibts eine Diskussionsseite um Sachen zu klären. Das ist deine private Diskussionsseite!<br />
Umbruch muss man weglassen da ja jeder andere Bildschirmbreiten besitzt. Natürlich kannst du bei Absätzen etc. einen Umbruch oder eine Leerzeile einfügen. Nur nicht in jeder Zeile. Am besten schaust du dir immer andere Artikel mit ÄNDERN an.<br />
--[[Benutzer:Frank|Frank]] 19:55, 14. Jan 2006 (CET)<br />
<br />
----<br />
<br />
Hallo Frank.<br />
Bisschen umständlich das ganze mit den Diskussionen...<br />
Da sieht man schlecht was jeder schreibt.<br />
Bei eMail kann man zu jedem Kommentar anworten und man sieht trotzdem, was jeder geschrieben hat.<br />
Aber egal.. Muss wohl damit leben ;-)<br />
<br />
Habe inzwischen alle BR gelöscht..<br />
Geht eigentlich so auch , nur halt mehr in einer Wurst...<br />
<br />
Ein paar Fragen hätte ich noch !!<br />
<br />
*Hast Du meine eMail bekommen wegen dem Thema Bascom ? (wohin u.s.w.)<br />
<br />
*Wie kann ich meine Beiträge in den Berreich Software ablegen, oder kann das nur ein Admin. ?<br />
<br />
* Bei "Bascom interupts", könntest Du bitte das "Interrupt" gross schreiben ?<br />
(kann das leider nicht ändern)<br />
<br />
* Wie kann ich meine eigenen Bilder löschen ???<br />
Habe da eines , zu grosses , hoch geladen und bei einem ist das Copyright falsch...<br />
<br />
* Wenn ich in zukunft eine Frage an dich habe, soll ich dann hier schreiben oder per eMAil ?<br />
<br />
* kann diese Diskusion dann eigentlich jeder lesen ?<br />
<br />
Ich glaube, einstweilen wären das alle Fragen ;-) :-)<br />
--[[Benutzer:Roberto|Roberto]] 21:31, 14. Jan 2006 (CET)<br />
<br />
<br />
----<br />
Hallo<br />
<br />
'''Zu deinen Fragen:'''<br />
<br />
* Mail hab ich keine bekommen. Musst du nochmal an webmaster... senden.<br />
* Ob du Bilder löschen kannst weiss ich nicht genau, zumindets Updaten müsstest du diese können. Einfach mal draufklicken dann solltest du Menüpunkt darunter finden. oder über Bilderliste oben im Menü.<br />
Zu große Bilder entweder updaten oder einfach verkleinern bei der Darstellung. Schau dazu mal in die Editierhilfe oder auch dir einfach mit ÄNDERN einige Artikel an wo kleinere Bilder zu sehen sind. Auf der Testseite ist glaub auch ein Beispiel. Wenn es ganz weg soll, kannst du einen Löschantrag einbauen. Schau dazu auch mal in die Hilfe, ist ganz leicht. Ein Mod oder ich löschen es dann. (siehe [[Hilfe:FAQ]])<br />
* Fragen kannst du im Forum posten (wenns eilig ist und für andere auch interessant ist), in der Artikeldiskussion (wenns zum Artikel passt) oder ne Mail.<br />
* Diskussionen kann jeder lesen, das ist bei Artikeldiskussionen ja immer Vorteilhaft<br />
* Man kann nichts in einer bestimmten Kategorie ablegen. Man teilt den Artikels durch den kategorie Befehl eine Kategorie zu. Bei deinen Artikeln hab ich das unten schon mehrfach gemacht. Dadurch sollte der Artikel dann in den passenden Rubriken erscheinen. Steht aber auch in der Editierhilfe [[RN-Wissen:Editierhilfe]]<br />
* Ach so, das umbenennen von Artikeln geht nicht so einfach, können eigentlich nur Moderatoren. Ich habs mal gemacht: [[Bascom Interrupts]]<br />
<br />
Hat man erst mal alles raus ist es eigentlich alles recht einfach. <br />
<br />
Gruß Frank<br />
<br />
== Bascom und Counter ==<br />
<br />
Hallo,<br />
mir ist aufgefallen das der Artikel [[Bascom und Counter]] seit längerem auf<br />
Status Artikelbaustelle steht. <br />
Solltest du den Artikel erstmal nicht fertig machen wollen, vielleicht aus Zeitmangel, dann gib bescheid. Wir könnten ihn dann erstmal löschen (ist ja noch leer). Artikelbaustellen sollten nicht zu lange offen sein.<br />
<br />
Gruß<br />
<br />
--[[Benutzer:Frank|Frank]] 12:52, 31. Jan 2006 (CET)<br />
<br />
<br />
Hallo Frank<br />
<br />
Ja, ich komme ledier derzeit nicht dazu...<br />
Ist vielleicht doch besser den einstweilen zu löschen..<br />
<br />
Was anderes..<br />
Es gibt ja inzwischen schon ein paar Artikel zu Bascom (timer,Verzweigungen u.s.w..) <br />
Vielleicht könnte man das irgendwo zusammenlegen... ? Unter Bascom oder so ?<br />
Oder unter Software/Bascom vielleicht ?!<br />
<br />
Was meinst Du dazu ?!<br />
--[[Benutzer:Roberto|Roberto]] 20:47, 31. Jan 2006 (CET)</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Benutzer_Diskussion:Roberto&diff=5737Benutzer Diskussion:Roberto2006-01-31T19:47:55Z<p>Roberto: </p>
<hr />
<div>Hi,<br />
du machst feine Artikel!<br />
Aber bitte nicht jede Zeile mit <nowiki><BR></nowiki> umbrechen. Der Text sollte gewöhnlich fließend eingegeben werden, nur bei Absätzen entweder Leerzeilen oder halt <nowiki><BR></nowiki> einfügen. Nur so ist sichergestellt das der Artikel in allen Auflösungen nett aussieht. <br />
Wenn Du willst kannst du die Bilder mittig anzeigen lassen, ich hab es bei ersten bild im pwm Artikel mal gemacht.<br />
--[[Benutzer:Frank|Frank]] 14:15, 14. Jan 2006 (CET)<br />
<br />
Noch eine Bitte, bei Artikel nicht die eigene Homepage drunter schreiben, außer es gehört zum Thema (dann aber unter Weblinks). Also nur den BenutzerNamen. Persönliche Angaben wie Homepage kannst du ja auf deiner Benutzerseite angeben. Ich habs mal probehalber mal für dich gemacht.<br />
<br />
hier [[Benutzer:Roberto|Roberto]]<br />
<br />
Hallo Frank.<br />
Ganz ist mir das mir den Diskusions sachen nicht klar.<br />
Hoffe ich schreibe hier jetzt richtig rein ?!<br />
<br />
Wenn ich ohne Umbruch mache, steht ja alles in einer Wurst ?<br />
Das schaut ja nach nix aus.<br />
Was macht es den eigentlich, wenn ich mehr BR's verwende ??<br />
--[[Benutzer:Roberto|Roberto]] 17:10, 14. Jan 2006 (CET)<br />
<br />
<br />
Ja du schreibst hier schon richtig! Zu jedem Artikel gibts eine Diskussionsseite um Sachen zu klären. Das ist deine private Diskussionsseite!<br />
Umbruch muss man weglassen da ja jeder andere Bildschirmbreiten besitzt. Natürlich kannst du bei Absätzen etc. einen Umbruch oder eine Leerzeile einfügen. Nur nicht in jeder Zeile. Am besten schaust du dir immer andere Artikel mit ÄNDERN an.<br />
--[[Benutzer:Frank|Frank]] 19:55, 14. Jan 2006 (CET)<br />
<br />
----<br />
<br />
Hallo Frank.<br />
Bisschen umständlich das ganze mit den Diskussionen...<br />
Da sieht man schlecht was jeder schreibt.<br />
Bei eMail kann man zu jedem Kommentar anworten und man sieht trotzdem, was jeder geschrieben hat.<br />
Aber egal.. Muss wohl damit leben ;-)<br />
<br />
Habe inzwischen alle BR gelöscht..<br />
Geht eigentlich so auch , nur halt mehr in einer Wurst...<br />
<br />
Ein paar Fragen hätte ich noch !!<br />
<br />
*Hast Du meine eMail bekommen wegen dem Thema Bascom ? (wohin u.s.w.)<br />
<br />
*Wie kann ich meine Beiträge in den Berreich Software ablegen, oder kann das nur ein Admin. ?<br />
<br />
* Bei "Bascom interupts", könntest Du bitte das "Interrupt" gross schreiben ?<br />
(kann das leider nicht ändern)<br />
<br />
* Wie kann ich meine eigenen Bilder löschen ???<br />
Habe da eines , zu grosses , hoch geladen und bei einem ist das Copyright falsch...<br />
<br />
* Wenn ich in zukunft eine Frage an dich habe, soll ich dann hier schreiben oder per eMAil ?<br />
<br />
* kann diese Diskusion dann eigentlich jeder lesen ?<br />
<br />
Ich glaube, einstweilen wären das alle Fragen ;-) :-)<br />
--[[Benutzer:Roberto|Roberto]] 21:31, 14. Jan 2006 (CET)<br />
<br />
<br />
----<br />
Hallo<br />
<br />
'''Zu deinen Fragen:'''<br />
<br />
* Mail hab ich keine bekommen. Musst du nochmal an webmaster... senden.<br />
* Ob du Bilder löschen kannst weiss ich nicht genau, zumindets Updaten müsstest du diese können. Einfach mal draufklicken dann solltest du Menüpunkt darunter finden. oder über Bilderliste oben im Menü.<br />
Zu große Bilder entweder updaten oder einfach verkleinern bei der Darstellung. Schau dazu mal in die Editierhilfe oder auch dir einfach mit ÄNDERN einige Artikel an wo kleinere Bilder zu sehen sind. Auf der Testseite ist glaub auch ein Beispiel. Wenn es ganz weg soll, kannst du einen Löschantrag einbauen. Schau dazu auch mal in die Hilfe, ist ganz leicht. Ein Mod oder ich löschen es dann. (siehe [[Hilfe:FAQ]])<br />
* Fragen kannst du im Forum posten (wenns eilig ist und für andere auch interessant ist), in der Artikeldiskussion (wenns zum Artikel passt) oder ne Mail.<br />
* Diskussionen kann jeder lesen, das ist bei Artikeldiskussionen ja immer Vorteilhaft<br />
* Man kann nichts in einer bestimmten Kategorie ablegen. Man teilt den Artikels durch den kategorie Befehl eine Kategorie zu. Bei deinen Artikeln hab ich das unten schon mehrfach gemacht. Dadurch sollte der Artikel dann in den passenden Rubriken erscheinen. Steht aber auch in der Editierhilfe [[RN-Wissen:Editierhilfe]]<br />
* Ach so, das umbenennen von Artikeln geht nicht so einfach, können eigentlich nur Moderatoren. Ich habs mal gemacht: [[Bascom Interrupts]]<br />
<br />
Hat man erst mal alles raus ist es eigentlich alles recht einfach. <br />
<br />
Gruß Frank<br />
<br />
== Bascom und Counter ==<br />
<br />
Hallo,<br />
mir ist aufgefallen das der Artikel [[Bascom und Counter]] seit längerem auf<br />
Status Artikelbaustelle steht. <br />
Solltest du den Artikel erstmal nicht fertig machen wollen, vielleicht aus Zeitmangel, dann gib bescheid. Wir könnten ihn dann erstmal löschen (ist ja noch leer). Artikelbaustellen sollten nicht zu lange offen sein.<br />
<br />
Gruß<br />
<br />
--[[Benutzer:Frank|Frank]] 12:52, 31. Jan 2006 (CET)<br />
<br />
<br />
Hallo Frank<br />
<br />
Ja, ich komme ledier derzeit nicht dazu...<br />
Ist vielleicht doch besser den einstweilen zu löschen..<br />
<br />
Was anderes..<br />
Es gibt ja inzwischen schon ein paar Artikel zu Bascom (timer,Verzweigungen u.s.w..) <br />
Vielleicht könnte man das irgendwo zusammenlegen... ? Unter Bascom oder so ?<br />
Oder unter Software/Bascom vielleicht ?!<br />
<br />
Was meinst Du dazu ?!<br />
--[[Benutzer:Roberto|Roberto]] 20:47, 31. Jan 2006 (CET)</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_Timer&diff=5700Bascom und Timer2006-01-30T07:37:12Z<p>Roberto: /* Timer im 1 Sekunden Takt */</p>
<hr />
<div>== Bascom Timer (Mega8 und andere) ==<br />
<br />
<br />
=== Zweck ===<br />
[[Timer]] sind selbständige Zähler im Prozessor. Man braucht sie dort, wo zeitkritische und genaue Aufgaben gefordert sind.<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
Config TimerXXX = Timer, Prescale= XX ‘Konfiguriere TimerXXX<br />
Enable TimerXXX ‘schalte den TimerXXX ein<br />
On TimerXXX SprungXXX ‘verzweige bei TimerXXX überlauf zu SprungXXX<br />
Enable Interrupts ‘generell Interrupts zulassen<br />
<br />
Do<br />
....Hauptprogramm ‘Hauptprogramm<br />
Loop<br />
End<br />
<br />
SprungXXX: ‘Unterprogramm von TimerXXX<br />
....Ausführung ‘arbeitet hier etwas ab und springt mit Return <br />
Return ‚ wieder zurück, zum Hauptprogramm<br />
</pre><br />
<br />
<br />
Zuerst muss man den zu verwendeten Timer mit „Config“, konfigurieren. <br />
Dazu definiert man ihn als Timer (mann könnte auch einen Counter daraus machen).<br />
Dazu muss man noch den Prescaler definieren. >Der Prescaler ist der Teiler, der die Quarzfequenz für den Timer reduziert .<br />
(Sonst würde der Timer immer mit der vollen Frequenz vom Quarz zählen und das würde meistens zu schnell sein.)<br />
<br />
Dann mit „Enable“ den bestimmten Timer einschalten. <br />
Mit „On“ das Unterprogramm (ISR) definieren, an die der Timer springen soll, <br />
wenn dieser überläuft(ISR= Interrupt Service Routine). Dann das generelle Einschalten von Interrupts.<br />
<br />
Jeder Zähler hat eine bestimmte, maximale Zählweite. Zählt er über diese, fängt er wieder bei Null an zu zählen (Überlauf).<br />
Wie weit ein Zähler zählen kann, ergibt sich aus seiner Struktur. Es gibt da 8-Bit Timer (Timer0 und Timer2, beim Mega8)und 16-Bit Timer (Timer1 beim Mega8).<br />
8-Bit Timer zählen bis 256, 16-Bit Timer bis 65536.<br />
<br />
Bei einem Überlauf, unterbricht der Timer das Hauptprogramm und springt in die ISR. Die ISR wird abgearbeitet und mit Return wird wieder an <br />
die Stelle zurückgesprungen, wo vorher das Hauptprogramm unterbrochen wurde. <br />
<br />
Man soll darauf achten, dass in der ISR immer nur kurze Anweisungen abgearbeitet <br />
werden und der Hauptteil dann im Hauptprogramm bearbeitet wird. <br />
Sonst kann es sein, dass man den Prozessor damit blockiert.<br />
<br />
=== Timer Beispiel: ===<br />
<pre><br />
Config Timer0 = Timer, Prescale= 8 ‘Konfiguriere Timer0<br />
Enable Timer0 ‘schalte den Timer0 ein<br />
On Timer0 Isr_von_Timer0 ‘verzweige bei Timer0 überlauf zu Isr_von_Timer0<br />
Enable Interrupts <br />
<br />
Do<br />
....Hauptprogramm<br />
Loop<br />
End<br />
<br />
Isr_von_Timer0: ‘ISR von Timer0<br />
.....Programm-Code<br />
Return<br />
</pre><br />
<br />
Timer0 ist nun so eingestellt, dass die Frequenz vom Quarz, durch den Prescaler, durch 8 geteilt wird.<br><br />
(Beim Prescaler kann man Teilungen von 1 , 8 , 64, 256, oder 1024 einstellen).<br> Diese Frequenz kommt nun zum Timer0 und der zählt nun mit dieser Frequenz bis 256.<br />
Ab 256 läuft der Timer über, fängt wieder bei Null an zu zählen, und verzweigt dabei in die ISR.<br />
Mit Return springt die ISR dann wieder zum Hauptprogramm zurück.<br />
In der ISR könnte man z.B. eine Variable hochzählen. Diese würde dann bei einem 8Mhz Quarz, ca. 3906mal in der Sekunde um 1 hochgezählt. ( (8000000Hz/8) /256=3906.26Hz)<br />
<br />
<br />
<br />
=== Timer im 1 Sekunden Takt ===<br />
<br />
Wenn man jetzt z.B. will, dass eine Variable nur alle Sekunden um 1 hochgezählt wird, muss man den Prescaler anpassen und auch noch die Zählweite vom Timer anpassen.<br />
Die Zählweite vom Timer kann man nur insovern verändern, dass man ihn nicht von Null weg zählen lässt, sondern von einem höheren Wert.(der Überlauf ist immer der maximale Wert vom Timer)<br />
<br />
Da der Timer0 aber mit 8-Bit jetzt zu kurz zählt (0-256) und wir mit einem grossen Prescaler auch nicht auf 1 Sekunde kommen, nehmen wir dazu den Timer1.<br />
<br />
Der Timer1 ist ein 16-Bit Timer und kann von 0-65536 zählen.<br />
<br />
Wenn ich jetzt einen Prescaler von 256 verwende, bekomme ich bei einem 8Mhz Quarz, eine Taktrate von 31250Hz. Das heist, dass der Zähler in einer Sekunde von 0 bis 31250 zählt. Wenn ich jetzt will, dass der Timer nach 31250 Zählungen überläuft (weil nur beim Überlaufen springt er in die ISR und zählt somit meine Variable um 1 hoch), darf ich den Timer nicht von Null wegzählen lassen sondern von einem höheren Wert.<br />
<br />
Dazu muss ich die maximale mögliche Zählweite (16-Bit = 65536) von meiner gewünschten Zählweite, abziehen. Also 65536-31250 = 34286 .Der Timer muss also schon bei 34286 zu zählen anfangen und macht dann nach 1 Sekunde einen Überlauf. 34286+31250= 65536 = Überlauf<br />
<br />
Hier ein Beispiel mit dem Timer 1.<br />
Zur Kontrolle wird eine Led im Sekundentakt aus und ein geschalten.<br />
Man kann in der ISR auch eine Variable hochzählen lassen.<br />
<pre><br />
$regfile = "m8def.dat" 'für Mega8 <br />
$crystal = 8000000 'für 8MHz Quarz<br />
<br />
Config Portd = Output 'definiert Portd als Output<br />
<br />
Config Timer1 = Timer , Prescale = 256 'Konfiguriere Timer1<br />
Enable Timer1 'schalte den Timer1 ein<br />
On Timer1 Isr_von_timer1 'verzweige bei Timer1 überlauf zu Isr_von_Timer1<br />
Enable Interrupts<br />
Timer1 = 34286 'Timer1 soll schon von 34286 wegzählen<br />
<br />
Do<br />
'....Hauptprogramm<br />
Loop<br />
End<br />
<br />
Isr_von_timer1: 'ISR von Timer1<br />
Timer1 = 34286 'Timer1 soll wieder von 34286 wegzählen<br />
Toggle Portd.0 'schaltet Portd.0 im Sekundentakt<br />
'EIN und AUS<br />
'....oder z.B. incr Variable <br />
<br />
Return<br />
</pre><br />
<br />
Die Vorgabe (Timer1=34286) soll man vor dem Hauptprogramm reinsetzen und bei der ISR.<br />
Wenn man die Vorgabe nicht bei der ISR reinsetzen würde (ISR = Überlauf), würde er ja wieder bei 0 statt bei 34286 anfangen zu zählen.<br />
<br />
Um sich das Rechnen zu ersparen könnte man statt der Anweisung: Timer1 = 34286 , auch den Befehl "Load" verwenden. <br />
<br />
Man gibt dann ein: Load Timer1 , 31250 <br><br />
<br />
Mit Load rechnet sich der Compiler selber die Werte aus ( 65536-31250 ).Man gibt einfach nach dem Komma, die beabsichtigte Zählweite ein.<br />
<br />
Damit hat man nun einen Timer der alle Sekunden eine Variable hochzählt.<br />
<br />
Um das Zählen der Sekunden noch genauer zu machen, müsste man noch die Zeiten für Sprung in die ISR u.s.w. mit einberechen. Aber für die meisten Anwendungen reicht diese Genauigkeit vollkommen aus ! :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Timer]]<br />
* [[Bascom]]<br />
* [[Interrupt]]<br />
<br />
==Weblinks==<br />
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool / Bascom Codegenerator]<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_Timer&diff=5699Bascom und Timer2006-01-30T07:34:00Z<p>Roberto: /* Timer im 1 Sekunden Takt */</p>
<hr />
<div>== Bascom Timer (Mega8 und andere) ==<br />
<br />
<br />
=== Zweck ===<br />
[[Timer]] sind selbständige Zähler im Prozessor. Man braucht sie dort, wo zeitkritische und genaue Aufgaben gefordert sind.<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
Config TimerXXX = Timer, Prescale= XX ‘Konfiguriere TimerXXX<br />
Enable TimerXXX ‘schalte den TimerXXX ein<br />
On TimerXXX SprungXXX ‘verzweige bei TimerXXX überlauf zu SprungXXX<br />
Enable Interrupts ‘generell Interrupts zulassen<br />
<br />
Do<br />
....Hauptprogramm ‘Hauptprogramm<br />
Loop<br />
End<br />
<br />
SprungXXX: ‘Unterprogramm von TimerXXX<br />
....Ausführung ‘arbeitet hier etwas ab und springt mit Return <br />
Return ‚ wieder zurück, zum Hauptprogramm<br />
</pre><br />
<br />
<br />
Zuerst muss man den zu verwendeten Timer mit „Config“, konfigurieren. <br />
Dazu definiert man ihn als Timer (mann könnte auch einen Counter daraus machen).<br />
Dazu muss man noch den Prescaler definieren. >Der Prescaler ist der Teiler, der die Quarzfequenz für den Timer reduziert .<br />
(Sonst würde der Timer immer mit der vollen Frequenz vom Quarz zählen und das würde meistens zu schnell sein.)<br />
<br />
Dann mit „Enable“ den bestimmten Timer einschalten. <br />
Mit „On“ das Unterprogramm (ISR) definieren, an die der Timer springen soll, <br />
wenn dieser überläuft(ISR= Interrupt Service Routine). Dann das generelle Einschalten von Interrupts.<br />
<br />
Jeder Zähler hat eine bestimmte, maximale Zählweite. Zählt er über diese, fängt er wieder bei Null an zu zählen (Überlauf).<br />
Wie weit ein Zähler zählen kann, ergibt sich aus seiner Struktur. Es gibt da 8-Bit Timer (Timer0 und Timer2, beim Mega8)und 16-Bit Timer (Timer1 beim Mega8).<br />
8-Bit Timer zählen bis 256, 16-Bit Timer bis 65536.<br />
<br />
Bei einem Überlauf, unterbricht der Timer das Hauptprogramm und springt in die ISR. Die ISR wird abgearbeitet und mit Return wird wieder an <br />
die Stelle zurückgesprungen, wo vorher das Hauptprogramm unterbrochen wurde. <br />
<br />
Man soll darauf achten, dass in der ISR immer nur kurze Anweisungen abgearbeitet <br />
werden und der Hauptteil dann im Hauptprogramm bearbeitet wird. <br />
Sonst kann es sein, dass man den Prozessor damit blockiert.<br />
<br />
=== Timer Beispiel: ===<br />
<pre><br />
Config Timer0 = Timer, Prescale= 8 ‘Konfiguriere Timer0<br />
Enable Timer0 ‘schalte den Timer0 ein<br />
On Timer0 Isr_von_Timer0 ‘verzweige bei Timer0 überlauf zu Isr_von_Timer0<br />
Enable Interrupts <br />
<br />
Do<br />
....Hauptprogramm<br />
Loop<br />
End<br />
<br />
Isr_von_Timer0: ‘ISR von Timer0<br />
.....Programm-Code<br />
Return<br />
</pre><br />
<br />
Timer0 ist nun so eingestellt, dass die Frequenz vom Quarz, durch den Prescaler, durch 8 geteilt wird.<br><br />
(Beim Prescaler kann man Teilungen von 1 , 8 , 64, 256, oder 1024 einstellen).<br> Diese Frequenz kommt nun zum Timer0 und der zählt nun mit dieser Frequenz bis 256.<br />
Ab 256 läuft der Timer über, fängt wieder bei Null an zu zählen, und verzweigt dabei in die ISR.<br />
Mit Return springt die ISR dann wieder zum Hauptprogramm zurück.<br />
In der ISR könnte man z.B. eine Variable hochzählen. Diese würde dann bei einem 8Mhz Quarz, ca. 3906mal in der Sekunde um 1 hochgezählt. ( (8000000Hz/8) /256=3906.26Hz)<br />
<br />
<br />
<br />
=== Timer im 1 Sekunden Takt ===<br />
<br />
Wenn man jetzt z.B. will, dass eine Variable nur alle Sekunden um 1 hochgezählt wird, muss man den Prescaler anpassen und auch noch die Zählweite vom Timer anpassen.<br />
Die Zählweite vom Timer kann man nur insovern verändern, dass man ihn nicht von Null weg zählen lässt, sondern von einem höheren Wert.(der Überlauf ist immer der maximale Wert vom Timer)<br />
<br />
Da der Timer0 aber mit 8-Bit jetzt zu kurz zählt (0-256) und wir mit einem grossen Prescaler auch nicht auf 1 Sekunde kommen, nehmen wir dazu den Timer1.<br />
<br />
Der Timer1 ist ein 16-Bit Timer und kann von 0-65536 zählen.<br />
<br />
Wenn ich jetzt einen Prescaler von 256 verwende, bekomme ich bei einem 8Mhz Quarz, eine Taktrate von 31250Hz. Das heist, dass der Zähler in einer Sekunde von 0 bis 31250 zählt. Wenn ich jetzt will, dass der Timer nach 31250 Zählungen überläuft (weil nur beim Überlaufen springt er in die ISR und zählt somit meine Variable um 1 hoch), darf ich den Timer nicht von Null wegzählen lassen sondern von einem höheren Wert.<br />
<br />
Dazu muss ich die maximale mögliche Zählweite (16-Bit = 65536) von meiner gewünschten Zählweite, abziehen. Also 65536-31250 = 34286 .Der Timer muss also schon bei 34286 zu zählen anfangen und macht dann nach 1 Sekunde einen Überlauf. 34286+31250= 65536 = Überlauf<br />
<br />
Hier ein Beispiel mit dem Timer 1.<br />
Zur Kontrolle wird eine Led im Sekundentakt aus und ein geschalten.<br />
Man kann in der ISR auch eine Variable hochzählen lassen.<br />
<pre><br />
$regfile = "m8def.dat" 'für Mega8 <br />
$crystal = 8000000 'für 8MHz Quarz<br />
<br />
Config Portd = Output 'definiert Portd als Output<br />
<br />
Config Timer1 = Timer , Prescale = 256 'Konfiguriere Timer1<br />
Enable Timer1 'schalte den Timer1 ein<br />
On Timer1 Isr_von_timer1 'verzweige bei Timer1 überlauf zu Isr_von_Timer1<br />
Enable Interrupts<br />
Timer1 = 34286 'Timer1 soll schon von 34286 wegzählen<br />
<br />
Do<br />
'....Hauptprogramm<br />
Loop<br />
End<br />
<br />
Isr_von_timer1: 'ISR von Timer1<br />
Timer1 = 34286 'Timer1 soll wieder von 34286 wegzählen<br />
Toggle Portd.3 'schaltet Pin1 vom Portd im Sekundentakt<br />
'EIN und AUS<br />
Return<br />
</pre><br />
<br />
Die Vorgabe (Timer1=34286) soll man vor dem Hauptprogramm reinsetzen und bei der ISR.<br />
Wenn man die Vorgabe nicht bei der ISR reinsetzen würde (ISR = Überlauf), würde er ja wieder bei 0 statt bei 34286 anfangen zu zählen.<br />
<br />
Um sich das Rechnen zu ersparen könnte man statt der Anweisung: Timer1 = 34286 , auch den Befehl "Load" verwenden. <br />
<br />
Man gibt dann ein: Load Timer1 , 31250 <br><br />
<br />
Mit Load rechnet sich der Compiler selber die Werte aus ( 65536-31250 ).Man gibt einfach nach dem Komma, die beabsichtigte Zählweite ein.<br />
<br />
Damit hat man nun einen Timer der alle Sekunden eine Variable hochzählt.<br />
<br />
Um das Zählen der Sekunden noch genauer zu machen, müsste man noch die Zeiten für Sprung in die ISR u.s.w. mit einberechen. Aber für die meisten Anwendungen reicht diese Genauigkeit vollkommen aus ! :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Timer]]<br />
* [[Bascom]]<br />
* [[Interrupt]]<br />
<br />
==Weblinks==<br />
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool / Bascom Codegenerator]<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5621Bascom und I2C EEprom2006-01-25T23:20:10Z<p>Roberto: /* Autor */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
==Weblinks==<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom Roboternetz-Thread]<br />
* [http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661 Roboternetz-Thread]<br />
<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5619Bascom und I2C EEprom2006-01-25T23:18:56Z<p>Roberto: /* Die Sache mit dem Overlay : */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5618Bascom und I2C EEprom2006-01-25T23:18:31Z<p>Roberto: /* Low/High Adressbereich mit Overlay leicht ansprechen */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5617Bascom und I2C EEprom2006-01-25T23:18:09Z<p>Roberto: /* Beispiel für EEprom 24C256 */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5616Bascom und I2C EEprom2006-01-25T23:17:09Z<p>Roberto: /* Das mit dem Overlay : */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Die Sache mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5615Bascom und I2C EEprom2006-01-25T23:16:47Z<p>Roberto: /* Das mit dem Overlay : */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Das mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160 - $161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5614Bascom und I2C EEprom2006-01-25T23:13:43Z<p>Roberto: </p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Das mit dem Overlay : ===<br />
<br />
Dim Adresse As Word At $160 <br />
<br />
Hier definiere ich die Variable für die Adresse vom I2C-EEprom, als Word-Variable. Die Variable soll ab Adresse $160 im Ram vom AVR abgelegt werden. Die Word-Variable hat einen Berreich von zwei Byte und braucht daher den Berreich von $160-$161<br />
<br />
<br />
Mit: <br />
Dim Low_adresse As Byte At $160 Overlay <br />
Dim High_adresse As Byte At $161 Overlay <br />
weise ich der neuen (Pseudo) Variablen "Low_adresse" einen Zeiger auf die Speicherstelle $160 zu und "High_adresse" einen Zeiger auf $161 zu.<br />
<br />
"Low_adresse" und "High_Adresse" sind also keine Variablen, sondern nur jeweils ein "Zeiger" auf diesen Speicherberreich der Variable: "Adresse" !<br />
<br />
Mit diesen zwei Zeigern habe ich automatisch jetzt meine Low und High Adressen für das I2C-EEprom.<br />
<br />
Ich kann diese zwei Zeiger jetzt ganz normal, wie Variablen, im Programm verwenden. :-)<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5613Bascom und I2C EEprom2006-01-25T22:56:51Z<p>Roberto: </p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
=== Das mit dem Overlay : ===<br />
<br />
<br />
<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5612Bascom und I2C EEprom2006-01-25T22:55:30Z<p>Roberto: /* Low/High Adressbereich mit Overlay leicht ansprechen */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom lesen/schreiben ==================================<br />
<br />
'===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5611Bascom und I2C EEprom2006-01-25T22:54:14Z<p>Roberto: /* Low/High Adressbereich mit Overlay leicht ansprechen */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom versuch V1.05==================================<br />
' ===========Für 24C256 EEprom=====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160 'Die Adresse als Word-Variable<br />
Dim Low_adresse As Byte At $160 Overlay 'Zeiger auf das erste Byte<br />
Dim High_adresse As Byte At $161 Overlay 'Zeiger auf das zweite Byte<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260 'Adresse geht über die Byte-Grenze<br />
Incr X '1 bis Überlauf<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " " 'Anzeige vom schreiben<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " " 'Anzeige vom lesen<br />
Waitms 500<br />
Next Adresse<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5610Bascom und I2C EEprom2006-01-25T22:48:00Z<p>Roberto: </p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Low/High Adressbereich mit Overlay leicht ansprechen ===<br />
<br />
<pre><br />
'============I2C EEprom versuch V1.05==================================<br />
<br />
' ===========Für 24C256 EEprom=====================<br />
<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
<br />
<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
<br />
Config Sda = Portd.5 ' I2C-Port festlegen<br />
Config Scl = Portd.7 ' I2C-Port festlegen<br />
<br />
<br />
Dim X As Byte<br />
Dim A As Word<br />
Dim B As Word<br />
Dim Schreiben As Byte<br />
Dim Lesen As Byte<br />
<br />
Dim Adresse As Word At $160<br />
Dim Low_adresse As Byte At $160 Overlay<br />
Dim High_adresse As Byte At $161 Overlay<br />
<br />
<br />
<br />
'===================Hauptprogramm===============================================<br />
Cls<br />
Lcd "I2C EEprom Test"<br />
Waitms 500<br />
Cls<br />
'-------------------------------------------------------------------------------<br />
<br />
Schreiben = 0<br />
<br />
Do<br />
<br />
'----schreiben----<br />
For Adresse = 250 To 260<br />
Incr X '1 bis Überlauf<br />
<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse<br />
I2cwbyte Low_adresse 'Sende Speicheradresse LOW<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'stop<br />
Waitms 10<br />
<br />
Locate 1 , 1<br />
Lcd "->Adres.=" ; Adresse ; "Wert=" ; X ; " "<br />
Waitms 500<br />
Next Adresse<br />
<br />
'---lesen----<br />
<br />
For Adresse = 250 To 260<br />
I2cstart 'Start<br />
I2cwbyte &HA0 'Sende Slavadresse +1 für Schreiben<br />
I2cwbyte Low_adresse 'Sende Speicheradresse Low<br />
I2cwbyte High_adresse 'Sende Speicheradresse High<br />
<br />
I2cstart 'Start<br />
I2cwbyte &HA1 'Sende Slavadresse +1 für Schreiben<br />
I2crbyte Lesen , Nack 'Lese Adresse vom EEprom<br />
I2cstop 'Stop<br />
<br />
Locate 2 , 1<br />
Lcd "<-Adres.=" ; Adresse ; "Wert=" ; Lesen ; " "<br />
Waitms 500<br />
Next Adresse<br />
<br />
<br />
<br />
Loop<br />
<br />
<br />
End<br />
<br />
</pre><br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5609Bascom und I2C EEprom2006-01-25T21:44:50Z<p>Roberto: /* Beispiel für EEprom 24C256 */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte. (Weil grösserer Speicherbereich im EEprom vorhanden ist)<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
<br />
'''Beispiel: ''' <br><br />
Wie Beispiel oben, nur mit erweiterten Adressbereich.<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5608Bascom und I2C EEprom2006-01-25T21:40:19Z<p>Roberto: /* Beispiel für EEprom 24C16 */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
Schleife A, schreibt den Wert 1-10 in die Speicherstelle 1-10 <br><br />
Schleife B, liest Speicherstelle 1-10 wieder aus und zeigt dies auch am LCD an.<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte.<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
'''Beispiel: '''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5607Bascom und I2C EEprom2006-01-25T21:11:17Z<p>Roberto: /* Siehe auch */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte.<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
'''Beispiel: '''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]<br />
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5606Bascom und I2C EEprom2006-01-25T21:10:20Z<p>Roberto: /* Siehe auch */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte.<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
'''Beispiel: '''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
*[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]]<br />
*[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]]<br />
*[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]]<br />
*[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5605Bascom und I2C EEprom2006-01-25T21:09:05Z<p>Roberto: /* Allgemein */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]<br />
<br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte.<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
'''Beispiel: '''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]]<br />
[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]]<br />
[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]]<br />
[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]]</div>Robertohttps://rn-wissen.de/wiki/index.php?title=Bascom_und_I2C_EEprom&diff=5604Bascom und I2C EEprom2006-01-25T21:08:36Z<p>Roberto: /* Allgemein */</p>
<hr />
<div>== Ansteuern vom I2C EEprom's mit Bascom ==<br />
<br />
<br />
<br />
<br />
=== Allgemein ===<br />
[[I2C]]/<br><br />
[http://www.eseo.de/i2c.htm ESEO-Home]<br />
<br />
=== Struktur: ===<br />
<br />
<pre><br />
<br />
'---- schreiben ins EEprom ----------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse<br />
I2cwbyte Speicheradresse<br />
I2cwbyte Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
<br />
'--- lesen vom EEprom --------------------------------------------<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse <br />
I2cwbyte Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte Slave Adresse +1 für schreiben<br />
I2crbyte lese Wert<br />
I2cstop 'Stop I2C<br />
</pre><br />
<br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C16 ===<br />
Zum besseren Verständniss werden hier die I2C Befehle untereinander geschrieben.<br />
In einem grösserem Programm, empfiehlt sich aber eine Sub-Routine zu deklarieren, die dann den Schreib/lese Vorgänge abwickelt.<br />
<br />
'''Beispiel :'''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C16 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
<br />
CLS<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
<br />
<br />
=== Beispiel für EEprom 24C256 ===<br />
<br />
EEprom 24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte.<br />
Darum muss man den Adressberreich in Low und High Adressbereich trennen.<br />
(Zuerst Low-Adressbereich schreiben und dann High-Adressberreich)<br />
<br />
'''Beispiel: '''<br />
<pre><br />
'============I2C EEprom schreiben/lesen ==================================<br />
<br />
' =========== Für 24C256 EEprom =====================<br />
' 8MHz Quarz<br />
' LCD auf Port B ,<br />
'<br />
$regfile = "m8def.dat"<br />
$crystal = 8000000<br />
<br />
'---Config für LCD -----------------<br />
Config Lcd = 40 * 2<br />
Config Lcdpin = Pin , Db4 = Portb.0 , Db5 = Portb.1 , Db6 = Portb.2 , Db7 = Portb.3 , Rs = Portb.4 , E = Portb.5<br />
Config Lcdbus = 4<br />
Config Lcdmode = Port<br />
Cursor On<br />
<br />
<br />
'SDA und SCL definieren<br />
Config Sda = Portd.5 <br />
Config Scl = Portd.7 <br />
<br />
<br />
Dim X As Byte<br />
Dim A As Byte<br />
Dim B As Byte<br />
Dim Lesen As Byte<br />
CLS<br />
<br />
Do<br />
'---- schreibe in EEprom ----<br />
For A = 1 To 10<br />
Incr X '1 bis Überlauf zählen<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'Sende Slave Adresse<br />
I2cwbyte A 'Sende Speicheradresse LOw<br />
I2cwbyte 1 'Sende Speicheradresse High<br />
I2cwbyte X 'Sende Wert<br />
I2cstop 'Stop I2C<br />
Waitms 10 'warte 10ms<br />
<br />
Locate 1 , 1<br />
Lcd "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD<br />
Waitms 500<br />
Next A<br />
<br />
<br />
'--- lesen vom EEprom ----<br />
For B = 1 To 10<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA0 'sende Slave Adresse <br />
I2cwbyte B 'sende Speicheradresse Low<br />
I2cwbyte 1 'sende Speicheradresse High<br />
<br />
I2cstart 'Start I2C<br />
I2cwbyte &HA1 'sende Slave Adresse +1 für schreiben<br />
I2crbyte Lesen , Nack 'lese Adresse vom EEprom<br />
I2cstop 'Stop I2C<br />
<br />
Locate 2 , 1<br />
Lcd "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte<br />
Waitms 500<br />
Next B<br />
<br />
Loop<br />
End<br />
</pre><br />
<br />
==Autor==<br />
* [[Benutzer:Roberto|Roberto]]<br />
<br />
<br />
==Siehe auch==<br />
* [[Avr]]<br />
* [[Bascom]]<br />
* [[EEPROM]]<br />
* [[I2C]]<br />
<br />
<br />
[[Kategorie:Robotikeinstieg]]<br />
[[Kategorie:Microcontroller]]<br />
[[Kategorie:Software]]<br />
[[Kategorie:Praxis]]<br />
[[Kategorie:Quellcode Bascom]]<br />
<br />
'''Aus dem Forum'''<br />
[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12086&highlight=eeprom]]<br />
[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=15433&highlight=eeprom]]<br />
[[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=10945&highlight=eeprom]]<br />
[[http://www.roboternetz.de/phpBB2/viewtopic.php?t=15661]]</div>Roberto