IT-Academy Logo
Sign Up Login Help
Home - Programmieren - C++ - C - Programmierung



C - Programmierung

Eine Einführung in die Programmiersprache C. Zusätzlich sind die wichtigsten Befehle erklärt und der Aufbau eines Programms.


Autor: Gabi Schütz (similie)
Datum: 11-11-2003, 00:34:57
Referenzen: Manuel W.
Schwierigkeit: Anfänger
Ansichten: 51407x
Rating: 8 (9x bewertet)

Hinweis:

Für den hier dargestellte Inhalt ist nicht der Betreiber der Plattform, sondern der jeweilige Autor verantwortlich.
Falls Sie Missbrauch vermuten, bitten wir Sie, uns unter missbrauch@it-academy.cc zu kontaktieren.

[Druckansicht] [Als E-Mail senden] [Kommentar verfassen]



1. Variablen

1.1 Globale Variablen

Es können globale Variablen definiert werden. Diese stehen dann für alle Unterfunktionen zur Verfügung, sprich int main() usw. Diese Variablen werden folgendermassen definiert:

#include 

	int variable = 5;

int main()
{
	printf("Die Variable ist eine globale Variable");
	printf("Die Variable ist %d gross", variable);
	return 0;
}

int test()
{
	printf("Die Variable ist %d gross und kann auch hier verwendet werden", variable);
	return 0;
}
1.2 Lokale Variablen

Diese werden innerhalb einer Funktion definiert, sprich in der Funktion int main() usw. Diese sind dann nur für diese Funktion verfügbar. Diese Variablen werden folgendermassen definiert:

#include 

int main()
{
	int variable = 5;
	printf("Die Variable ist %d gross und kann nur in
	int main() verwendet werden", variable);
	return 0;
}

int test()
{
	printf("Hier kann die Variable nicht verwendet werden");
	return 0;
}
1.3 Verschiedene Typen von Variablen

Es gibt verschiedene Typen von Variablen:
  • Integer (int)
  • Float (float)
  • Double (double)
  • Char (char)
Integer-Variablen werden benötigt um Ganzzahlen zu speichern.
Float-Variablen werden benötigt um Zahlen mit Kommastellen zu speichern. Kommastelle ist auf 7 Stellen genau.
Double-Variablen werden auch benötigt um Zahlen mit Kommastellen zu speichern. Kommastelle ist auf 15 Stellen genau.
In Char-Variablen wird die Zahl der ASCII-Tabelle gespeichert, z.B. die Zahl 65 für den Buchstaben A.
Die verschiedenen Variablen werden folgendermaßen definiert:


#include 

int main()
{
	int variable1; 	/* Eine Integer-Variable */
	float variable2; 	/* Eine Float-Variable */
	double variable3;	/* Eine Double-Variable */
	char variable4;	/* Eine Char-Variable */

	variable1 = 5;	/*Weise der Variablen einen Wert zu */
	variable2 = 5.5;
	variable3 = 5.26589;
	variable4 = ’P’;	/* Weise ein Zeichen zu */

	printf("Auf die Variablen kann folgendermaßen zugegriffen werden:");
	printf("%d 	%2.3f  %1.4f  c", variable1, variable2, variable3, variable4);
	return 0;
}
Mit %d kann eine Integer-Variable ausgegeben werden. Anstelle von %d erscheint dann beim ausführen des Programms der Inhalt der Variablen.
Mit %f können Float- oder Double-Variablen ausgegeben werden. Mit der Zahl zwischen % und f kann definiert werden wie viele Kommastellen er anzeigen soll. Z.B. %4.5f zeigt die Variable beim Ausführen des Programms mit 4 Stellen vor dem Komma und 5 Stellen nach dem Komma an.
Mit %c kann der Inhalt einer Char Variablen ausgegeben werden.

1.4 Rechnen mit Variablen

Die Integer- und Float-Variablen haben einen dezimalen Zahlenwert gespeichert. Mit diesen Variablen kann ganz normal gerechnet werden mit den Operatoren: + - * /. Wenn mit zwei Variablen gerechnet wird, muss das Resultat immer einer Variablen zugewiesen werden. Dies könnte so aussehen:

#include 

int main()
{
	int zahl1 = 5;
	int zahl2 = 6

	zahl1 = zahl1 + zahl2;
	/* Es wird  die Zahl1 und die Zahl2  zusammengezählt und in Zahl1
	   gespeichert. Gleich funktioniert es mit anderen Operatoren */

	zahl1 = 25 + 35;
	/* Der Variablen Zahl1 wird das Resultat der Rechnung 25 + 35
	   zugewiesen */

	return 0;
 
}
Vielfach muss zu einem Wert eins dazu oder eins abgezählt werden. Dies wird meistens in Schlaufen der Fall sein. Um die kurz zu schreiben genügt:

zahl1 ++;    Es wird eins zum Wert der Variablen zahl1 dazugezählt,
zahl1 --;      Es wird eins vom Wert der Variablen zahl1 abgezählt.
2. Erste Schritte eines Programmes

Als erstes werden immer die Bibliotheken angegeben. Als Standart kann man immer eingefügt werden. Dieses steht dann immer zuoberst bei einem Programm. Beispiel:

#include 

int main()
{
}
Um ein Programm zu beginnen, müssen die Unterprogramme benannt werden. Es muss immer ein Programm mit dem Name int main() vorhanden sein. Das Programm beginnt bei diesem mit Arbeiten. Es können jedoch auch andere Unterprogramme erstellt werden, wie z.B. int test(). Dies kann dann von der Funktion main aus angesprochen werden. Ein Unterprogramm beginnt mit einer "{" und endet mit einer "}". Das ganze sieht dann so aus:

#include 

int main()
{
	/* Zwischen diesen zwei Klammern kann alles definiert werden */
}

int test()
{
/* int test ist ein weiteres Unterprogramm. Es wird mit einem Befehl
im Unterprogramm main aufgerufen, wird dann ausgeführt und wenn es abgelaufen ist,
springt er wieder an diesen Punkt im Programm main zurück an welchem das Unterprogramm
test aufgerufen wurde. Nun wird das Programm main weiterlaufen. */
}
3. Verschiedene Befehle

3.1 printf()

Printf ist der Standartbefehl für eine Ausgabe auf dem Bildschirm. Er wird folgendermassen angewandt:

#include 

int main()
{
	int variable = 5;
	char zeichen = ’D’;
	printf("Die Integervariable: %d und
	die Charactervariable: %c", variable, zeichen);
	return 0;
}
Zwischen den zwei " " kann alles beliebige geschrieben werden. Es gibt jedoch einige nützliche Befehle:
\n für einen neuen Absatz
\a für einen Beeb-Ton
\t für einen Tabulatorschlag

3.1.1 Übung 1

Gegeben sind die Variablen: zahl, zeichen. Geben Sie der Variablen Zahl den Wert 12345 und weisen Sie der Variablen zeichen das Zeichen U zu. Geben Sie die beiden Variablen so aus, das sie untereinander stehen und um eine Tabulator versetzt stehen. Rechnen Sie nur die Variable zahl minus 2000 und geben Sie diese zwei Absätze weiter unten aus. Schliessen Sie das Programm mit einem Beeb-Ton ab.

3.2 scanf()

Mit dem Befehl scanf() kann ein Wert über die Tastatur eingelesen und in eine Variable abgespeichert werden. Man beachte einfach, dass Buchstaben und Sonderzeichen in eine Character-Variable gespeichert werden müssen. Um ein scanf auszuführen muss zuerst eine Variable deklariert werden und den eingelesenen Wert darin zu speichern. Hier ein Beispiel:

#include 

int main()
{
	int zahl1;
	scanf("%d", &zahl1);
	/* Eine Zahl wird eingelesen und in die Variable zahl1 gespeichert */
	printf(„%d", zahl1);
	return 0;
}
3.3 getchar() / putchar()

Mit dem Befehl getchar kann auch ein Wert über die Tastatur eingelesen werden. Der eingelesene Wert kann nur in ein Character-Variable gespeichert werden. Auch bei diesem Befehl muss zuerst eine Variable deklariert werden, damit der Wert darin gespeichert werden kann. Um den gespeicherten Wert wieder auszugeben, kann der Befehl putchar verwendet werden. Hier ein kleines Beispiel:

#include 

int main()
{
char zeichen;
zeichen = getchar();
putchar(zeichen);
return 0;
}
3.4 gets() / puts()

Mit gets kann eine ganze Zeichenkette (String) eingelesen werden, sprich ein ganzer Satz oder eine folge von Buchstaben und Sonderzeichen. Dies funktioniert jedoch nur mit einem Array. Arrays werden später noch erklärt. Mit puts kann dieser String dann wieder ausgegeben werden. Hier ein Beispiel:

#include 

int main()
{
	char zeichen[100];  /* Variable Zeichen ist ein Array */
	gets(zeichen);         /* Der String wird eingelesen */
	puts(zeichen);         /* Der String wird ausgegeben */
	return 0;
}
Ein String wird in einen Array abgelegt. Für jeden Buchstabe eine neue Spalte. Genaueres sehen Sie unter Arrays. Ein Char-String wird immer am Schluss mit einem \0 abgeschlossen.

3.5 if()

Mit dem Befehl if kann eine Variable überprüft werden. If auf Deutsch übersetzt heißt wenn. Somit lässt sich dieser Befehl leicht erklären. Wenn(hier die Bedingung) dann mache: Ansonsten mache: Im Programm sieht das so aus:

#include 

int main()
{
	int zeichen = 5;

	if(zeichen == 5)
	/* Wenn der Wert von Zeichen gleich ist wie 5 */
	{
		printf("Der Wert der Variablen ist 5");
	/* Dann mache dies: */ 
	}
	else
	/* Ansonsten mache dies: */
	{
		printf(„Der Wert der Variablen ist nicht gleich 5");
	}
	return 0;
}
Um Variablen zu vergleichen können alle Vergleichsoperatoren gebraucht werden.
== 	gleich 	Achtung es müssen zwei == hintereinander geschrieben werden
> < 	grösser als und kleiner als
!=		nicht gleich
Es können auch zwei Variablen verglichen werden:

#include 

int main()
{
	int variable1 = 5;
	int variable2 = 6;

	if(variable1 > variable2)
	{
		printf("Variable 1 ist grösser");
	}
	else
	{
		printf("Variable 2 ist grösser");
	}
	return 0;
}
Alles was er ausführen soll, wenn die Bedingung zutrifft oder nicht zutrifft, muss zwischen den zwei Klammern { } stehen.

3.6 while()

While auf Deutsch übersetzt heisß solange. D.h. solange die Definition in der Klammer zutrifft werden die angegebenen Befehle ausgeführt. Hier kann wieder mit den Vergleichsoperatoren gearbeitet werden. Ein kleines Beispiel:

#include 

int main()
{
	int index = 0;

	while(index != 5)
	/* Solange index nicht gleich 5 mache: */
	{
		index ++;
    /* Zähle zum Wert von Index eins dazu */
		printf("Das ist der %d. Durchgang\n", index);
    /* Macht nun bei jedem Durchgang einen printf */
	}
	return 0;
}
Auch hier muss alles, was ausgeführt werden soll, in den zwei Klammern { } stehen.

3.7 switch() - case

Mit switch kann eine Variable nach verschiedenen Werten überprüft werden. Mit case wird dann angegeben was ausgeführt werden soll, wenn die Bedingung zutrifft. Ein kleines Beispiel:

#include 

int main()
{
	int zahl = 3;
	switch(zahl)
	{
		case 1 : printf("Zahl gleich 1"); break;
		/* Ist die Zahl gleich 1 mache: */
		case 2 : printf("Zahl gleich 2"); break;
		/* Ist die Zahl gleich 2 mache: */
		case 3 : printf("Zahl gleich 3"); break;
		/* Ist die Zahl gleich 3 mache: */
		case 4 : printf("Zahl gleich 4"); break;
		/* Ist die Zahl gleich 4 mache: */
		default : printf("Zahl nicht zwischen 1-4"); break;
		/* Stimmt nichts vom oberen mache: */
	}
	return 0;
}
Dies kann auch mit Buchstaben gemacht werden. Jedoch muss der Buchstaben in Hochkommas ’A’ stehen. Nach dem Doppelpunkt wir angegeben was ausgeführt werden soll. Hier kann man alles beliebige angeben.

3.8 Array

Arrays sind Variablen, in denen mehrere Werte oder ganze Zeichenketten gespeichert werden können. Man kann angeben, wie groß bzw. wie viele Elemente in einer Variablen Platz haben. Z.B. int zahl[10]; ist ein statischer Array. In dieser Variablen haben 10 Elemente Platz oder ein Satz mit 10 Buchstaben inkl. Leerschlag. Man kann aber auch dynamisch Array deklarieren. Z.B. int zahl[]. Wenn ein dynamischer Array deklariert wird, muss ihm der Inhalt gleich angegeben werden. Z.B. int zahl[] = {25, 36, 25, 69, 98, 100}; Das ganze funktioniert so:

Name der Variablen: int zahl[] = {25, 36, 25, 69, 98, 100};
Adressbereich 0 1 2 3 4 5
Daten 25 36 25 69 98 100


Um nun eine dieser Zahlen anzusprechen, muss als erstes die Variable genannt werden, und anschließend in welche Spalte sich diese Zahl befindet. Das könnte für die Zahl 98 so aussehen: zahl[4]; mit diesem Befehl greift man auf die Spalte 4 der Variablen zahl zu. Wichtig ist, dass die Nummerierung der Spalten bei Null beginnt. Das Zugreifen auf statische Arrays funktioniert gleich wie bei dynamischen. Der Unterschied liegt nur darin, dass man bei dynamischen Arrays die Zahlen angeben muss, die er beinhaltet und das keine feste Größe definiert wurde. In einem Programm könnte das folgendermassen aussehen:

#include 
#define max 5
/* Definiere einen Wert der immer gleich bleibt */

int main()
{
	int index = 0;
	int auswahl = 0;
	int test[max];
	/* Definiere den Array test mit der Größe von der Variablen max */
	while(index != max)
	/* Solange index nicht gleichgroß wie max mache: */
	{
		printf("Geben Sie den %d. Wert ein: ", index + 1);
		scanf("%d", &test[index]);
		/* Lese die Werte ein und speichere sie in den Array */
		index ++;
		/* Zähle zum Index eins dazu */
	}
	printf("Welchen Wert wollen Sie anschauen 1-5? ");
	scanf("%d", &auswahl);
	/* Lese die Auswahl ein und speichere die Zahl in auswahl */
	auswahl --;
	/* Zähle von der Variablen auswahl eins ab */
	printf("Der %d. Wert ist: %d", auswahl + 1, test[auswahl]);
	/* Gebe den Wert aus */
	return 0;
}


Mogwei
Rookie
Beitrag vom:
31-10-2008, 21:48:12

Passt scho!

Jo hallo!
Ich hab vor ein paar Tagen mit Programmieren in C angefangen, weil ichs für die Uni brauch. Und das Tutorial hier hat mir schon weitergeholfen! Kann schon sein, dass da einige Grundlagen fehlen, aber es ist genug Material hier, um einen Anfänger wie mich (und für solche ist es gedacht) über Stunden hin zu beschäftigen. Mit den Sachen rumzuprobieren dauert eben seine Zeit. Ich hab noch nich alles ausprobiert, aber bis jetzt funktioniert alles, was dort beschrieben wird.


-----------------------------------------------------


paedubucher
Professonial
Beitrag vom:
16-05-2004, 22:32:43

Gute Grundlagenerläuterung

Also, ich muss zuerst mal sagen, ich finde den Artikel ganz gut. For Schleifen usw. fehlen zwar, es werden hier aber nur die Grundlagen erklärt (wenn ich die Grundlagen Windows erkläre muss ich auch nicht dokumentieren wie man ein Netzwerk erstellt)...

Den #Include Fehler musst du aber unbedingt noch einmal überarbeiten! Ich gebe dir (in der Hoffnung auf Überarbeitung des Include-Fehlers) mal eine 8.

-----------------------------------------------------


picard
Professonial
Beitrag vom:
20-03-2004, 19:18:55

net: machs doch besser!

Groß daherjammern kann jeder - aber es besser machen?! Falls Du der Meinung bist, dass hier essentielle Dinge fehlen, dann schreib doch einen "besseren" Artikel!

-----------------------------------------------------
"...denn wir arbeiten nicht nur um uns selbst zu verbessern, sondern auch den Rest der Menschheit!"


similie
Insider
Beitrag vom:
19-03-2004, 07:25:00

Mit dem "einsamen #include" hast du recht, es sollte eigentlich überall #include heissen, ist im Originalartikel auch drin, allerdings muss dass beim Veröffentlichen hier weggekommen sein (kann also nichts dafür)

-----------------------------------------------------
Aus einem verkniffenen Arsch kommt nie ein glücklicher Furz


net
Rookie
Beitrag vom:
18-03-2004, 15:09:10

nochmal....

naja, wenn nur pointer fehlen würden, wärs ja nicht so schlimm aber es fehlen fundamentale dinge wie
- for schleifen
- short, long, unsigned
- do...while
- funktionsaufrufe, rückgabewert, übergabeparameter
- ....
muss ich noch mehr aufzählen?

btw: das einsame #include erzeugt bei mir (vc++):
error C2006: '#include' : Dateinamen erwartet, aber 'newline' gefunden

-----------------------------------------------------


Dani
Senior Member
Beitrag vom:
18-03-2004, 14:28:20

mein senf zu deinem senf

Der Code kompiliert so einwandfrei. Es sind aber keine Variablen, die da verwendet werden. Das ist falsch ausgedrückt. AFAIK würde das Beispiel mit Variablen gar nicht funktionieren.

Außerdem pointer in einer *Einführung*? Bitte nicht!

-----------------------------------------------------
\"I have to share the credit. I may have invented it, but I think Bill made it famous. -- When he used it for the NT logon, that\'s what I meant. okay?\" (David Bradley über Ctrl-Alt-Del)


similie
Insider
Beitrag vom:
18-03-2004, 10:48:26

Zum Kommentar von net

Ich hab hier eine Einführung mit Betonung auf EINFÜHRUNG in die Programmiersprache C geschrieben, die ANFÄNGERN die wichtigsten GRUNDLAGEN erklären sollte. Die Codes sind problemlos kompilierbar und funktionieren tadellos

-----------------------------------------------------
Aus einem verkniffenen Arsch kommt nie ein glücklicher Furz


net
Rookie
Beitrag vom:
18-03-2004, 09:53:36

mein senf

dieses tutorial ist sehr schlecht, voller fehler und unvollständig. es fehlen wichtige dinge wie pointer, structures, modulo-operator usw. das einsame #include vor jedem codeabschnitt ist überflüssig und mich würde es wundern, wenn die codes so compilierbar sind zitat: #define max 5 int test[max]; /* Definiere den Array test mit der Größe von der Variablen max */ max ist keine variable sondern eine konstante, die der preprozessor mit dem wert 5 ersetzt. alles in allem: ich empfehle der autorin, sich eingehender mit der materie zu befassen bevor sie tutorials schreibt.

-----------------------------------------------------


Rolfhub
Senior Member
Beitrag vom:
11-11-2003, 22:45:23

Wichtiger Unterschied zu anderen Programmiersprachen

Was man (meiner Meinung nach) bei C/C++ zum Thema Arrays unbedingt dazusagen sollte, da dies in zahlreichen anderen Programmiersprachen nicht so ist: Bei C/C++ findet beim Zugriff auf Arrays keine Bereichsprüfung statt, d.h. wenn das Array 5 Elemente hat, und ich auf das Element '5' (also auf das sechste) zugreife, kann das Programm abstürzen, da ich auf eine Speicherposition außerhalb des Arrays zugreife. Warum dies so ist? Keine Ahnung, durch die fehlende Prüfung wird natürlich Rechenzeit gespart, aber wenn eine derartige Prüfung stattfinden würde, wären manche Programmfehler sicherlich leichter zu finden.

-----------------------------------------------------


red
Junior-Member
Beitrag vom:
11-11-2003, 11:58:48

anfänger

... allerdings würde ich es nicht umbedingt als anfänger einstuffen da sehr wenig grundlage erklärt werden

-----------------------------------------------------


red
Junior-Member
Beitrag vom:
11-11-2003, 11:57:43

C

Hallo! Habe es mir selbst mal angesehen und habe diese buch dazu verwendet war echt klasse! http://www.amazon.de/exec/obidos/ASIN/3499600749/302-3529644-2580801

-----------------------------------------------------


[back to top]



Userdaten
User nicht eingeloggt

Gesamtranking
Werbung
Datenbankstand
Autoren:04508
Artikel:00815
Glossar:04116
News:13565
Userbeiträge:16552
Queueeinträge:06246
News Umfrage
Ihre Anforderungen an ein Online-Zeiterfassungs-Produkt?
Mobile Nutzung möglich (Ipone, Android)
Externe API Schnittstelle/Plugins dritter
Zeiterfassung meiner Mitarbeiter
Exportieren in CSV/XLS
Siehe Kommentar



[Results] | [Archiv] Votes: 1154
Comments: 0