Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
Vorwort des Gutachters
1 Einstieg in C
2 Das erste Programm
3 Grundlagen
4 Formatierte Ein-/Ausgabe mit »scanf()« und »printf()«
5 Basisdatentypen
6 Operatoren
7 Typumwandlung
8 Kontrollstrukturen
9 Funktionen
10 Präprozessor-Direktiven
11 Arrays
12 Zeiger (Pointer)
13 Kommandozeilenargumente
14 Dynamische Speicherverwaltung
15 Strukturen
16 Ein-/Ausgabe-Funktionen
17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C)
18 Arbeiten mit variabel langen Argumentlisten – <stdarg.h>
19 Zeitroutinen
20 Weitere Headerdateien und ihre Funktionen (ANSI C)
21 Dynamische Datenstrukturen
22 Algorithmen
23 CGI mit C
24 MySQL und C
25 Netzwerkprogrammierung und Cross–Plattform-Entwicklung
26 Paralleles Rechnen
27 Sicheres Programmieren
28 Wie geht’s jetzt weiter?
A Operatoren
B Die C-Standard-Bibliothek
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
C von A bis Z von Jürgen Wolf
Das umfassende Handbuch
Buch: C von A bis Z

C von A bis Z
3., aktualisierte und erweiterte Auflage, geb., mit CD und Referenzkarte
1.190 S., 39,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1411-7
Pfeil 17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C)
Pfeil 17.1 Attribute einer Datei ermitteln – »stat()«
Pfeil 17.1.1 »stat()« – »st_mode«
Pfeil 17.1.2 »stat()« – »st_size«
Pfeil 17.1.3 »stat()« – »st_atime«, »st_mtime« und »st_ctime«
Pfeil 17.1.4 »stat()« – »st_gid« und »st_uid«
Pfeil 17.1.5 »stat()« – »st_nlink«, »st_ino«
Pfeil 17.1.6 »stat()« – »st_dev«, »st_rdev«
Pfeil 17.2 Prüfen des Zugriffsrechts – »access()«
Pfeil 17.3 Verzeichnisfunktionen
Pfeil 17.3.1 Verzeichnis erstellen, löschen und wechseln – »mkdir()«, »rmdir« und »chdir«
Pfeil 17.3.2 In das Arbeitsverzeichnis wechseln – »getcwd()«
Pfeil 17.3.3 Verzeichnisse öffnen, lesen und schließen – »opendir()«, »readdir()« und »closedir()«


Rheinwerk Computing - Zum Seitenanfang

17.3 Verzeichnisfunktionen Zur nächsten ÜberschriftZur vorigen Überschrift

Bei den bisherigen ANSI-C-Funktionen konnte es Ihnen egal sein, wie ein Dateisystem aufgebaut ist. Es gibt zwar einige systemabhängige Faktoren, die zu beachten sind (beispielsweise das Trennzeichen von Verzeichnisnamen), aber meistens sind diese Funktionen so universell implementiert, dass es dennoch nicht zu Problemen kommt. Bei einem Zugriff auf Verzeichnisse ist es leider nicht mehr so einfach. Hierbei werden meist POSIX-konforme Funktionen verwendet, die vorwiegend in der UNIX-Welt beheimatet sind. Keine Sorge, auch MS-Windows-Anwender können diese Funktionen nutzen. In vielen Compilern unter diesem System sind diese Funktionen integriert.


Rheinwerk Computing - Zum Seitenanfang

17.3.1 Verzeichnis erstellen, löschen und wechseln – »mkdir()«, »rmdir« und »chdir« Zur nächsten ÜberschriftZur vorigen Überschrift

#include <sys/types.h>  /* Linux/UNIX */
#include <sys/stat.h>   /* Linux/UNIX */
#include <dir.h>        /* MS-DOS/WIN */

int mkdir(const char *pfad, [int modus]);

Mit der Funktion mkdir() wird ein neues Verzeichnis mit dem Namen pfad angelegt. Zusätzlich werden in dem neuen Verzeichnis automatisch auch das Arbeitsverzeichnis (Working Directory) (.) und das Eltern-Verzeichnis (Parent Directory) (..) mit angelegt. Die Zugriffsrechte können über modus vergeben werden. Dies gilt aber nur für Linux/UNIX und nicht für Windows/MS-DOS. Die Modi unter Linux/UNIX entnehmen Sie bitte der Manpage von chmod().

Hierzu sehen Sie als Beispiel ein Listing, mit dem ein neues Verzeichnis erstellt wird.

/* create_dir.c */
#ifdef __unix__
   #include <sys/types.h>
   #include <sys/stat.h>
   #define MODUS ,0711)
#elif __WIN32__ || _MS_DOS_
    #include <dir.h>
    #define MODUS )
#else
    #include <direct.h>  /* Visual C++ */
    #define MODUS )
#endif
#include <stdio.h>
#include <stdlib.h>

int main(void) {
   char pfadname[200];

   printf("Wie soll der neue Ordner heissen: ");
   scanf("%199s",pfadname);
   if(mkdir(pfadname MODUS == -1) /*Nicht schön, aber portabler*/
      printf("Konnte kein neues Verzeichnis erstellen\n");
   else
      printf("Neues Verzeichnis namens %s erstellt\n",pfadname);
   return EXIT_SUCCESS;
}

Wurde das Programm ausgeführt, sollte sich im benannten Verzeichnis ein neuer Ordner mit dem eingegebenen Namen befinden. Unter Linux/UNIX muss außerdem beachtet werden, dass für den modus auch die Ausführrechte (Execute-Bits) gesetzt sind, um auch Zugriff auf das neue Verzeichnis zu haben.

Sofern versucht wird, ein Verzeichnis zu erstellen, das bereits existiert, wird dies fehlschlagen. errno wird dann auf einen entsprechenden Wert gesetzt (EEXIST).


Hinweis

Es soll hierbei nicht unerwähnt bleiben, dass Sie unter Linux/UNIX nicht einfach die Zugriffsrechte für ein neues Verzeichnis bzw. eine neue Datei vergeben können, wie es Ihnen gerade passt. Sie sind dabei von einer gewissen Bit-Einschränkungsmaske abhängig, die Sie allerdings mit der Funktion umask() verändern können. Dies ist allerdings sehr systemspezifisch. Daher möchte ich Sie auf mein anderes Buch »Linux-UNIX-Programmierung« hinweisen, das Sie auch zum Probelesen auf meiner Homepage vorfinden.


Als Nächstes soll in das eben erstellte Verzeichnis gewechselt werden. Dies gelingt mit der Funktion chdir(). Die Syntax von chdir() sieht so aus:

#include <unistd.h> /* Linux/UNIX */
#include <dir.h>    /* MS-DOS/WIN */

int chdir(const char *pfad);

Mit chdir() wird in das Arbeitsverzeichnis gewechselt, das jedes ablaufende Programm besitzt. Bei einem Fehler gibt diese Funktion –1 zurück, ansonsten 0. In dem folgenden Listing wird erst ein neues Verzeichnis erstellt, und danach wird mit chdir() in das erstellte Verzeichnis gewechselt und darin eine Textdatei erzeugt.

/* change_dir.c */
#ifdef __linux__
   #include <sys/types.h>
   #include <sys/stat.h>
   #include <unistd.h>
   #define MODUS ,0711)
#elif _WIN32__ || _MS_DOS_
    #include <dir.h>
    #define MODUS )
#else
    #include <direct.h>
    #define MODUS )
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main(void) {
   char pfadname[200];

   printf("Wie soll der neue Ordner heissen : ");
   scanf("%199s",pfadname);
   if(mkdir(pfadname MODUS == -1)
      printf("Konnte kein neues Verzeichnis erstellen\n");
   else {
      printf("Neues Verzeichnis namens %s erstellt\n", pfadname);
      printf(" --> (%s)\n", strerror(errno));
   }

   /* Jetzt wollen wir in das neue Verzeichnis wechseln. */
   if(chdir(pfadname) == -1) {
      printf("Konnte nicht in das Verzeichnis wechseln\n");
      return EXIT_FAILURE;
   }
   else
      printf("Erfolgreich nach %s gewechselt!\n", pfadname);
   /* testfile im Verzeichnis erstellen*/
   fopen("testfile", "w");
   return EXIT_SUCCESS;
}

Jetzt sollte sich in dem eben erzeugten Verzeichnis eine Datei namens testfile befinden. Es dürfte Ihnen aufgefallen sein, dass das Programm, wenn es sich beendet, automatisch wieder in das Verzeichnis des Elternprozesses zurückwechselt.

Wenn Sie mehrmals in einem Programm Verzeichnisse erstellen müssen und in diese wechseln, schreiben Sie besser eine Funktion wie z. B.:

int makedir(char *dir) {
   if(mkdir(dir, 0755) != -1) /* Windows/MS-DOS ohne 0755 */
      if(chdir(dir) != -1)
         return OK;
   return ERROR;
}

Wollen Sie ein Verzeichnis wieder löschen, können Sie die Funktion rmdir() verwenden. Die Syntax von rmdir() lautet:

#include <unistd.h>   /* UNIX/Linux */
#include <dir.h>      /* MS-DOS     */

int rmdir(const char *pfad);

Mit rmdir() kann ein Verzeichnis (rmdir steht für remove directory) gelöscht werden. Unter Linux/UNIX setzt dies allerdings voraus, dass dieses Verzeichnis außer dem (.) und (..) keinen anderen Eintrag mehr beinhaltet. Bei Erfolg gibt diese Funktion 0 zurück und bei einem Fehler –1.

Dazu soll das Programm, das eben verwendet wurde, erweitert werden. Das Verzeichnis, das erstellt wurde, in das gewechselt wurde und in dem eine Datei erzeugt wurde, soll am Ende des Programms wieder gelöscht werden. Hier sehen Sie das Listing dazu:

/* remove_dir.c */
#ifdef __linux__
   #include <sys/types.h>
   #include <sys/stat.h>
   #include <unistd.h>
   #define MODUS ,0711)
#elif _WIN32__ || _MS_DOS_
    #include <dir.h>
    #define MODUS )
#else
    #include <direct.h>
    #define MODUS )
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int makedir(char *dir) {
   if(mkdir(dir MODUS != -1)
      if(chdir(dir) != -1)
         return 0;
   return -1;
}

int main(void) {
   char pfadname[200];

   printf("Wie soll der neue Ordner heissen : ");
   scanf("%199s",pfadname);

   if(makedir(pfadname) == -1) {
      printf("Konnte kein neues Verzeichnis erstellen\n");
      printf(" --> (%s)\n", strerror(errno));
   }
   /* testfile im Verzeichnis erstellen */
   fopen("testfile","w");

   if(rmdir(pfadname) == -1) {
     printf("Konnte Verzeichnis %s nicht loeschen!!\n",pfadname);
     printf(" --> (%s)\n", strerror(errno));
   }
   return EXIT_SUCCESS;
}

Unter MS-DOS/Windows wird das Listing problemlos funktionieren. Mit Linux/UNIX kann das Verzeichnis nicht gelöscht werden, da sich dort noch eine Datei befindet. Das Verzeichnis muss also zuvor leer sein. Das vollständige Verzeichnis lässt sich mit folgendem Shell-Aufruf leeren:

rmdir Verzeichnis | rm -rf Verzeichnis

Im Listing kann dieser Aufruf folgendermaßen eingesetzt werden:

/* remove_dir_unix.c */
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

int main(void) {
   char pfadname[200];
   char deletefiles[200];

   printf("Welchen Ordner wollen Sie löschen : ");
   scanf("%189s",pfadname);
   strcpy(deletefiles,"rm -rf ");
   strcat(deletefiles,pfadname);
   strcat(deletefiles,"/*");
   printf("%s\n",deletefiles);
   system(deletefiles);
   if(rmdir(pfadname) == -1) {
      printf("Konnte Verzeichnis %s nicht löschen!!\n",pfadname);
      printf(" --> (%s)\n", strerror(errno));
   }
   return EXIT_SUCCESS;
}

Rheinwerk Computing - Zum Seitenanfang

17.3.2 In das Arbeitsverzeichnis wechseln – »getcwd()« Zur nächsten ÜberschriftZur vorigen Überschrift

Mit der Funktion getcwd() lässt sich der Name des Arbeitsverzeichnisses (Working Directory) ermitteln. Die Syntax von getcwd() lautet:

#include <unistd.h>    /* Linux/UNIX */
#include <dir.h>       /* MS-DOS/WIN */

char *getcwd(char *puffer, int puffergroesse);

Die Funktion schreibt in die Speicheradresse puffer den Pfadnamen des Arbeitsverzeichnisses mit abschließendem '\0'. Mit puffergroesse wird die Größe des Puffers angegeben. Die Funktion gibt bei Erfolg den Pfadnamen des Arbeitsverzeichnisses an puffer zurück oder bei einem Fehler NULL. Hier sehen Sie ein Beispiel dafür, wie diese Funktion verwendet wird:

/* working_D.c */
#ifdef __unix__
    #include <unistd.h>
#elif __WIN32__ || _MS_DOS_
    #include <dir.h>
#else
    #include <direct.h> /* Visual C++ */
#endif
#include <stdio.h>
#include <stdlib.h>

int main(void) {
   char puffer[200];

   if(getcwd(puffer,sizeof(puffer)) == NULL) {
      fprintf(stderr, "Fehler bei getcwd ...\n");
      return EXIT_FAILURE;
   }
   printf("Working-Directory: %s\n", puffer);
   return EXIT_SUCCESS;
}

Für Linux/UNIX gilt außerdem: Wechseln Sie in ein Verzeichnis, das ein symbolischer Link auf ein anderes Verzeichnis ist, so wird in das Verzeichnis gewechselt, auf das der symbolische Link zeigt.

Ein praktisches Beispiel unter Linux: Der User hat den Namen seines Home-Verzeichnisses vergessen. Er muss aber jetzt wieder in das Verzeichnis wechseln. Welches das ist, kann er mit der Eingabe des Shellbefehls env (Environment) oder mit der C-Funktion getenv()herausfinden. Hier sehen Sie das Listing:

/* go_home.c */
#ifdef __unix__
    #include <unistd.h>
#elif __WIN32__ || _MS_DOS_
    #include <dir.h>
#else
    #include <direct.h> /* Visual C++ */
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 200

int main(void) {
   char puffer[MAX];
   char home[MAX];
   if( getenv("HOME") == NULL ) {
      printf("getenv(\"HOME\") findet nichts\n");
      return EXIT_FAILURE;
   }
   /* das Heimatverzeichnis nach home */
   strncpy(home, getenv("HOME"), MAX-1);
   home[MAX-1] = '\0';
   /* Working Directory lesen */
   if(getcwd(puffer,sizeof(puffer)) == NULL) {
      fprintf(stderr, "Fehler bei getcwd ...\n");
      return EXIT_FAILURE;
   }
   /* Sind wir schon im Heimatverzeichnis? */
   if(strcmp(home,puffer) == 0)
      printf("Wir sind daheim : %s\n",puffer);
   else { /* Nicht, dann wechseln wir ins Heimatverzeichnis. */
      chdir(home);
      /* Der Beweis: */
      printf("back at home: %s \n",
         getcwd(puffer,sizeof(puffer)));
   }
   return EXIT_SUCCESS;
}

Rheinwerk Computing - Zum Seitenanfang

17.3.3 Verzeichnisse öffnen, lesen und schließen – »opendir()«, »readdir()« und »closedir()« topZur vorigen Überschrift

Um Verzeichnisse zu lesen, ist in der Headerdatei mit #include <dirent.h> eine interne Struktur namens DIR deklariert. Der Inhalt dieser Struktur ist hier jetzt nicht von Interesse, sondern es geht um die folgenden Funktionen, die mit der Struktur arbeiten.


Hinweis

Die folgenden Funktionen sind leider nicht mit dem Microsoft Visual-C++-Compiler ausführbar. Dafür wird aber am Ende des Kapitels ein extra Listing angefertigt, das zeigt, wie auch mit dem Visual-C++-Compiler Programme erstellt werden können, die ein Verzeichnis auslesen.



Tipp

Wollen Sie die folgenden Beispiele mit der kostenlosen Entwicklungsumgebung Bloodshed Dev-C++ durchführen, müssen Sie im Menü über ProjektProjektoptionen in der Liste Linker die Bibliothek -lmingwex eintragen. Eventuell kann dies aber auch über das Menü Werkzeuge CompilerOptionen in die Liste Linker eingetragen werden. Hierfür genügt aber dann folgender Eintrag: mingwex


»opendir()« – ein Verzeichnis öffnen

Wir beginnen mit der Funktion opendir():

#include <sys/types.h>
#include <dirent.h>

DIR *opendir(const char *dirname);

Bei Erfolg wird mit dieser Funktion das Verzeichnis dirname geöffnet, auf dessen Adresse dann der DIR-Zeiger verweist. Ansonsten wird bei einem Fehler NULL zurückgegeben.

Der DIR-Zeiger wird jetzt verwendet, um den Inhalt eines Verzeichnisses auszulesen. Dies wird jetzt gleich mit der Funktion readdir() vorgenommen.

»readdir()« – aus einem Verzeichnis lesen

Die Syntax von readdir() lautet:

#include <sys/types.h>
#include <dirent.h>

struct dirent *readdir(DIR *dir);

Bei einem Fehler gibt diese Funktion ebenfalls NULL zurück. Ansonsten gibt sie eine Adresse der Struktur dirent zurück, die Folgendes beinhaltet:

struct dirent {
   long d_ino;      /* i-node Nr. (bei Windows/MS-DOS immer 0) */
   unsigned short d_reclen;   /* (bei Windows/MS-DOS immer 0)  */
   unsigned short d_namlen;   /* Länge des Namens in d_name    */
   char *d_name;       /* Dateiname mit abschließendem '\0'    */
};

In der Praxis kann die Funktion readdir() so verwendet werden:

DIR *dir;
struct dirent *dirzeiger;
/* Verzeichnis öffnen */
if((dir=opendir(dirname)) != NULL)
/* komplettes Verzeichnis Eintrag für Eintrag auslesen */
while((dirzeiger=readdir(dir)) != NULL)
    printf("%s\n",(*dirzeiger).d_name);

Es wird zuerst mit opendir() ein Verzeichnis geöffnet und danach mit readdir() der komplette Inhalt des Verzeichnisses ausgegeben.

»rewinddir()« – Verzeichnis-Zeiger auf den Anfang zurücksetzen

Mit der Funktion rewinddir() wird der Lesezeiger wieder an den Anfang der Namensliste des Verzeichnisses zurückgesetzt. Die Syntax von rewinddir() lautet:

#include <sys/types.h>
#include <dirent.h>

void rewinddir(DIR *dir);

»closedir()« – Verzeichnis schließen

Am Ende wird dann mit der Funktion closedir() das Verzeichnis geschlossen, das mit opendir() geöffnet wurde. Bei Erfolg gibt diese Funktion 0 und bei Fehler –1 zurück. Die Syntax lautet:

#include <sys/types.h>
#inlcude <dirent.h>

int closedir(DIR *dir);

Hier folgt ein ausführbares Beispiel, das alle Funktionen in Aktion demonstriert:

/* read_dir.c */
#include <sys/types.h>
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
   DIR *dir;
   struct dirent *dirzeiger;

   if(argc != 2) {
      fprintf(stderr,"Benutzung : %s Directory\n", argv[0]);
      return EXIT_FAILURE;
   }
   /* das Verzeichnis öffnen */
   if((dir=opendir(argv[1])) == NULL) {
      fprintf(stderr,"Fehler bei opendir ...\n");
      return EXIT_FAILURE;
   }
   /* das komplette Verzeichnis auslesen */
   while((dirzeiger=readdir(dir)) != NULL)
      printf("%s\n",(*dirzeiger).d_name);
   /* Lesezeiger wieder schließen */
   if(closedir(dir) == -1)
      printf("Fehler beim Schließen von %s\n", argv[1]);
   return EXIT_SUCCESS;
}

Mit diesem Programm wird das vollständige Verzeichnis ausgegeben, das Sie über die Kommandozeile angeben.

»telldir()« und »seekdir()« – Positionierung im Verzeichnis

Auf einigen Systemen gibt es zusätzlich noch die Funktion telldir():

#include <sys/types.h>
#include <sys/dirent.h>

off_t telldir(DIR *dirptr)

Diese Funktion liefert zu einem mit readdir() gelesenen Verzeichnis die Position des Lesezeigers zurück.

Mit der Funktion seekdir() lässt sich die Position des DIR-Zeigers verschieben:

#include <sys/types.h>
#include <sys/dirent.h>

void seekdir(DIR *dirptr, off_t pos)

Damit wird der mit opendir() geöffnete Lesezeiger (dirptr) auf die Position pos gesetzt, die Sie zuvor mit der Funktion telldir() ermittelt haben. Hierzu noch ein kurzer Ausschnitt dieser beiden Funktionen:

off_t pos;
/* aktuelle Position im Verzeichnis ermitteln */
pos = telldir(dir_ptr);
/* viele Funktionen */
...
/* zur aktuellen Position zurückspringen */
seekdir(dir_ptr, pos);

Probleme mit der Portabilität

Ein Problem bei Funktionen wie opendir(), readdir() oder closedir() ist, dass sie POSIX-konform und aus diesem Grund häufig nicht bei Compilern für MS-Windows implementiert sind. Unter UNIX-artigen Systemen müssen Sie sich wegen dieser Funktionen keine Gedanken machen. Um also unter MS-Windows, genauer gesagt unter WIN32, ein vollständiges Verzeichnis auszugeben, müssen Sie auf die Windows-Systemprogrammierung zurückgreifen. Die Windows-Programmierung hier genauer zu erläutern, würde den Rahmen des Kapitels oder gar des Buchs sprengen. Aber zu Anschauungszwecken folgt hier eine portablere Lösung, mit der Sie ein vollständiges Verzeichnis ausgeben lassen können:

/* portabel_readdir.c */
#include <stdio.h>
#include <stdlib.h>
#ifdef __unix__
#include <dirent.h>
#include <sys/types.h>


/* UNIX-Funktion zum Ausgeben des kompletten Verzeichnisses */
void list_dir(const char *path) {
   DIR *dirptr;
   struct dirent *dir;

   if ((dirptr=opendir(path)) == NULL)
      return;
   while((dir=readdir(dirptr)) != NULL)
      printf("%s\n",dir->d_name);
   closedir(dirptr);
}

#elif __WIN32__ || _MSC_VER
#include <windows.h>
/* Win32-Funktion zum Ausgeben des kompletten Verzeichnisses */
void list_dir(const char *path) {
   WIN32_FIND_DATA dir;
   HANDLE fhandle;
   char directory[256];

   /* unsicher, besser wäre - falls vorhanden - snprintf() */
   sprintf(directory,"%s\\*.*",path);
   /* Handle auf das Verzeichnis directory */
   if ((fhandle=FindFirstFile(directory,&dir)) !=
                             INVALID_HANDLE_VALUE) {
      do {  /* Verzeichnis auslesen */
         printf("%s\n", dir.cFileName);
      } while(FindNextFile(fhandle,&dir));
   }
   FindClose(fhandle);
}
#endif

int main(int argc,char *argv[]) {
   if (argc < 2)
      list_dir(".");
   else
      list_dir(argv[1]);
   return EXIT_SUCCESS;
}

Bei der Win32-Funktion wurden hier die MS-DOS-ähnlichen Funktionen findfirst() und findnext() verwendet. Die Funktion FindFirstFile() gibt ein Filehandle auf die erste Datei im Verzeichnis zurück, während FindNextFile() das Handle immer um eine Position weitersetzt, bis keine Dateien mehr im Verzeichnis zum Lesen vorhanden sind. FindClose() schließt das Filehandle wieder.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  
  Zum Katalog
Zum Katalog: C von A bis Z

 C von A bis Z
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: C/C++






 C/C++


Zum Katalog: Einstieg in C






 Einstieg in C


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de