JK-Wiki edv:prg:c:man

edv:prg:c:man:dynamische_speicherverwaltung

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:12+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Dynamische Speicherverwaltung ======

	+	Header:
	+	<code c>
	+	#include <stdlib.h>
	+	</code>
	+
	+	Funktionen:
	+	<code c>
	+	void *malloc(size_t ElementGröße); // Memory Allocation
	+	void *calloc(size_t ElementAnzahl, size_t ElementGröße); // Cleared Memory Allocation
	+	void realloc(void PointerAufSpeicherBlock, size_t NeueSpeicherBlockGröße);
	+	void free(void *PointerAufSpeicherBlock);
	+	</code>
	+
	+	* malloc() - Speicher für ein einziges Element zuteilen. Der zugeteilte Speicher wird nicht initialisiert (bekommt einen undefinierten zufälligen Wert).
	+	* calloc() - Speicher für mehrere Elemente auf einmal zuteilen. Der zugeteilte Speicher wird mit 0 initialisiert.
	+	* realloc() - Die Größe des bereits zugeteilten Speicherblocks ändern. Beim Verkleinern wird einfach der "hintere Teil" des Speicherblocks freigegeben, während der "vordere Teil" unverändert bleibt. Beim Vergrößern des Speicherblocks behält der "vordere Teil" seinen Wert, der neue Teil wird einfach "hinten" angehängt. Dieser angehängte Wert ist wie bei malloc() undefiniert.
	+	* free() - gibt den Speicher, der durch malloc()/calloc() zugeteilt wurde, wieder frei.
	+
	+	:!: Auf Performance achten!\\
	+	Da der Speicher beim "re'alloc'ieren" u.U. auf eine andere Stelle wandert, wird der Inhalt vorher temporär zwischengespeichert und dann automatisch auf die neue Stelle kopiert.
	+
	+	:!: Bei free() folgendes unbedingt beachten:\\
	+
	+	* Falls ein (nicht mehr benötigter) Speicherbereich nicht freigegeben wird (weil z.B. der Pointer darauf nicht mehr zu ermitteln ist), bleibt er blokiert, bis der Prozess zu Ende ist. Falls die Zuteilung des Speichers mit malloc() in einer Schleife stattfindet, kann ein vergessenes free() schnell zum Swapping und danach zum Speicherüberlauf führen.
	+	* Falls ein Speicherbereich freigegeben wird, der nicht zuvor mit malloc(), calloc() oder realloc() zugeteilt wurde, kann dies katastrophale Folgen haben. Die ganze Speicherverwaltung kann so aus dem Tritt gebracht werden. Daher sollte man darauf achten, daß wirklich nur Speicherplatz freigegeben wird, der auch zugeteilt wurde.
	+	* Speicher, der mit free() freigeben wurde, wird während der Laufzeit des Prozesses nicht wirklich an den Kernel zurückgegeben, sondern in einem so genannten malloc()-Pool gehalten, um bei Bedarf während des laufenden Prozesses wieder darauf zurückgreifen zu können. Erst, wenn der Prozess beendet wurde, geht der Speicher wieder zurück an den Kern.
	+
	+	:!: Ich rate ausdrücklich von der Versuchung ab, Pointer in den int-artigen Variablen (z.B. ''unsigned long'') zu speichern! Auf den meisten 32-Bit Systemen entspricht zwar ein Pointer tatsächlich einem ''unsigned long''. Es wird sogar auf vielen 64-Bit Systemen funktionieren, aber nur solange die Speicherverwaltung Adressen aus dem unteren Adressbereich zurück liefert. Der Fehler kann somit lange Zeit unentdeckt bleiben.\\
	+	__Weitere Infos:__\\
	+	Im Bezug auf Windows siehe den MSDN-Artikel [[https://msdn.microsoft.com/en-us/library/bb613473(VS.85).aspx\|4-Gigabyte Tuning: BCDEdit and Boot.ini]].\\
	+	(Steuerung von ''virtual address space'' durch den RegistryKey HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Memory Management\AllocationPreference)\\
	+	Oder auch unter [[https://tedwvc.wordpress.com/2013/07/16/porting-win32-code-to-64-bit-watch-out-for-pointers/]]
	+
	+	__Zusammenfassung:__
	+
	+	Path: HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Memory Management\
	+	Key: AllocationPreference (vom Typ DWORD)
	+	Value: 0x100000
	+
	+
	+	Weitere Funktionen:
	+
	+	Header:
	+	<code c>
	+	// UNIX/Linux
	+	#include <stdlib.h>
	+
	+	// Windows/MS-DOS
	+	#include <malloc.h>
	+	</code>
	+
	+	Funktionen:
	+	<code c>
	+	// Kein Bestandteil von ANSI C, ist aber häufig vorhanden.
	+	void *alloca(size_t ElementGröße);
	+	</code>
	+
	+	Die Funktion alloca() ist ähnlich der malloc() mit dem Unterschied, daß alloca() den Speicher nicht vom Heap, sondern vom Stack anfordert. Aus diesem Grund muß dieser Speicher nicht explizit mit free() freigegeben werden. Beim Verlassen der Funktion, in der der Speicher zugeteilt wurde, ist der Stack weg - somit der zugeteilte Speicher auch.
	+
	+	Zur [[http://jk-wiki.kreick.de/doku.php?id=edv:prg:c#externe_links_zum_thema\|Kurzbeschreibung der 64-bit Datenmodelle]]
	+
	+	----
	+	Stand: 10.03.2015\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:man:makro_offsetof

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:13+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Makro offsetof() ======

	+	Um den Abstand der einzelnen Strukturelemente in Bytes zu ermitteln, kann dazu das Makro offsetof() verwenden werden, das im Header <stddef.h> deklariert ist:
	+
	+	<code c>
	+	#include <stddef.h>
	+
	+	size_t offsetof(struktur, name_strukturelement);
	+	</code>
	+
	+	Das Makro liefert den Abstand vom Anfang der Struktur bis zu dem Strukturelement, das als zweites Argument angegeben ist.
	+	Ist das Makro auf dem System nicht vorhanden, so lässt es sich wie folgt implementieren:
	+
	+	<code c>
	+	#define offsetof(struct_type, member) (size_t) &(((struct_type *)0)->member)
	+	</code>
	+
	+	Quelle: [[http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/015_c_strukturen_014.htm]]
	+
	+
	+	----
	+	Stand: 21.06.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:man:makros_min_und_max

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:12+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Makros min() und max() ======

	+	Es gibt bereits vordefinierte Makros um den kleinsten bzw. den größten der beiden Werte zu ermitteln.
	+
	+	In den VisualStudio Libraries heißen sie %%__min()%% und %%__max()%% und sind in <stdlib.h> definiert und können wie folgt aufgerufen werden:
	+
	+	<code c>
	+	#include <stdlib.h>
	+	#include <stdio.h>
	+
	+	int main( void )
	+	{
	+	int a = 10;
	+	int b = 21;
	+
	+	printf( "The larger of %d and %d is %d\n", a, b, __max( a, b ) );
	+	printf( "The smaller of %d and %d is %d\n", a, b, __min( a, b ) );
	+	}
	+	</code>
	+
	+	Quelle: [[http://msdn.microsoft.com/de-de/library/btkhtd8d(v=vs.100).aspx]]
	+
	+
	+	----
	+	Stand: 18.07.2014\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:man:zugriff_auf_das_filesystem

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:12+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Zugriff auf das FileSystem ======

	+	GNU C Library: [[http://www.gnu.org/software/libc/manual/html_node/File-System-Interface.html#File-System-Interface\|File System Interface]]
	+
	+	:!: Als Vorlage habe ich folgende Seite verwendet:\\ [[http://www.imb-jena.de/~gmueller/kurse/c_c++/c_file.html]]
	+
	+	Weitere Quellen:
	+	* Mit Verzeichnissen arbeiten: [[http://openbook.rheinwerk-verlag.de/linux_unix_programmierung/Kap02-004.htm]] (mkdir(), chdir(), fchdir(), rmdir(), struct dirent, opendir(), closedir(), scandir(), ftw(), etc.)
	+	* POSIX Reference, "dirent.h": [[https://en.wikibooks.org/wiki/C_Programming/POSIX_Reference/dirent.h]]
	+
	+	FIXME
	+
	+	===== stat() =====
	+
	+	stat() - Liefert Informationen über das File path und legt diese in der Struktur info ab.\\ :!: Das File muß __nicht geöffnet__ sein.
	+
	+	Deklaration:
	+	<code c>
	+	#include <sys/types.h>
	+	#include <sys/stat.h>
	+
	+	// ACHTUNG: nicht in ANSI C
	+	int stat(const char path, struct stat info);
	+	</code>
	+
	+	Die Struktur stat ist i.d.R. wie folgt aufgebaut:
	+
	+	<code c>
	+	struct stat
	+	{
	+	time_t st_atime; // Datum des letzten Zugriffs (atime)
	+	time_t st_ctime; // Datum der letzten Statusänderung (ctime)
	+	dev_t st_dev; // Gerätenummer
	+	gid_t st_gid; // Gruppennummer (GID)
	+	ino_t st_ino; // i-node Nummer
	+	mode_t st_mode; // Fileattribute
	+	time_t st_mtime; // Datum der letzten Modifikation (mtime)
	+	nlink_t st_nlink; // Anzahl der Verweise (links)
	+	off_t st_size; // Filegröße in Byte
	+	off_t st_blksize; // Blockgröße in Byte
	+	uid_t st_uid; // Eigentümernummer (UID)
	+	dev_t st_rdev; // Geräteidentifikationsnummer
	+	}; // struct stat
	+	</code>
	+
	+	Beispiel:
	+
	+	<code c>
	+	#include <stdio.h>
	+	#include <time.h>
	+	#include <sys/types.h>
	+	#include <sys/stat.h>
	+
	+	int main (int argc, char *argv[])
	+	{
	+	struct stat s;
	+
	+	stat(argv[0], &s);
	+
	+	printf("%-40s : %s\n", "File", argv[0]);
	+	printf("%-40s : %d\n", "size", s.st_size);
	+	printf("%-40s : %ud\n", "Attribute", s.st_mode);
	+	printf("%-40s : %d\n", "UID", s.st_uid);
	+	printf("%-40s : %d\n", "GID", s.st_gid);
	+	printf("%-40s : %s\n", "mtime", ctime(&s.st_mtime));
	+	printf("%-40s : %s\n", "ctime", ctime(&s.st_ctime));
	+	printf("%-40s : %s\n", "atime", ctime(&s.st_atime));
	+
	+	return 0;
	+	} // main()
	+	</code>
	+
	+	Es empfielt sich, bei der Auswertung der Status-Struktur das Flag S_IFMT zu berücksichtigen:
	+
	+	<code c>
	+	#include <sys/types.h>
	+	#include <sys/stat.h>
	+	#include <time.h>
	+	#include <stdio.h>
	+	#include <stdlib.h>
	+
	+	int main(int argc, char *argv[])
	+	{
	+	struct stat sb;
	+
	+	if (stat(argv[1], &sb) == -1)
	+	{
	+	perror("stat");
	+	exit(EXIT_FAILURE);
	+	}
	+
	+	printf("File type: ");
	+
	+	switch (sb.st_mode & S_IFMT)
	+	{
	+	case S_IFBLK: printf("block device\n"); break;
	+	case S_IFCHR: printf("character device\n"); break;
	+	case S_IFDIR: printf("directory\n"); break;
	+	case S_IFIFO: printf("FIFO/pipe\n"); break;
	+	case S_IFLNK: printf("symlink\n"); break;
	+	case S_IFREG: printf("regular file\n"); break;
	+	case S_IFSOCK: printf("socket\n"); break;
	+	default: printf("unknown?\n"); break;
	+	}
	+
	+	exit(EXIT_SUCCESS);
	+	}
	+	</code>
	+
	+	Infos unter [[http://man7.org/linux/man-pages/man2/stat.2.html]] oder [[http://linux.die.net/man/2/fstat]]
	+
	+	:!: In den Libraries aus MS Visual Studio heißt diese Funktion anders - etwa "_stat()", "_stat32()", "_stat64()" u.s.w.\\ Weitere Infos unter [[http://msdn.microsoft.com/en-us/library/14h5k7ff(v=vs.100).aspx]]
	+
	+	===== rename() =====
	+
	+	rename() - Ändert den Namen der Datei von oldname in newname. Beide Namen können vollständige Pfade beinhalten.\\ :!: Ist eine der Dateien zum Zeitpunkt des Aufrufs von rename() durch einen Prozeß geöffnet, so gibt rename() den Fehler EACESS zurück.
	+
	+	Deklaration:
	+	<code c>
	+	#include <stdio.h>
	+
	+	int rename(const char oldname, const char newname);
	+	</code>
	+
	+	Rückgabewert:
	+	0 - OK
	+	-1 - Fehler
	+
	+	Bei Fehlern wird in errno ein der folgenden Werte gespeichert:
	+	EACCES - Zugriff nicht gestattet
	+	ENOENT - Pfad/Datei nicht gefunden
	+	ENOTSAM - Ziel- und Quell-Laufwerk sind nicht identisch
	+
	+	Beispiel:
	+
	+	<code c>
	+	#include <stdio.h>
	+
	+	int main (void)
	+	{
	+	char oldname[80], newname[80];
	+
	+	stat(argv[0], &s);
	+
	+	printf("Umzubenennende Datei: ");
	+	gets(oldname);
	+	printf("Neuer Name : ");
	+	gets(newname);
	+
	+	if (rename(oldname, newname) == 0) printf("Datei [%s] wurde in [%s] umbenannt\n", oldname, newname);
	+	else perror("rename");
	+
	+	return 0;
	+	} // main()
	+	</code>
	+
	+	Wirkung von perror() z.B.:
	+	rename: No such file or directory
	+
	+
	+	===== remove() =====
	+
	+	FIXME
	+
	+	===== chmod() =====
	+
	+	FIXME
	+
	+	===== access() =====
	+
	+	access() - Stellt fest, ob ein Prozess bestimmte Berechtigungen für den Zugriff auf eine Datei hat.
	+
	+	<code c>
	+	#include <unistd.h> // für Unix/Linux
	+	#include <io.h> // für MS-DOS
	+
	+	int access(const char *pfad, int modus);
	+	</code>
	+
	+	Der Parameter %%modus%% kann dabei folgende Werte haben:
	+
	+	^Makro ^Wert ^Bedeutung ^
	+	\|F_OK \|00 \|Die Datei existiert. \|
	+	\|X_OK \|01 \|Die Datei ist ausführbar (nur Linux/Unix). \|
	+	\|W_OK \|02 \|Die Datei ist beschreibbar. \|
	+	\|R_OK \|04 \|Die Datei ist lesbar. \|
	+
	+	Rückgabewert:
	+	* 0 = OK
	+	* -1 = Fehler
	+
	+	Quelle: [[http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/017_c_dateien_verzeichnisse_002.htm]]
	+
	+	===== utime() =====
	+
	+	utime(), utimes() - Change file last access and modification times.
	+
	+	Quelle: [[http://man7.org/linux/man-pages/man2/utime.2.html]]
	+
	+	===== getcwd() =====
	+
	+	FIXME
	+
	+	===== mkdir() =====
	+
	+	FIXME
	+
	+	===== rmdir() =====
	+
	+	FIXME
	+
	+	===== chdir() =====
	+
	+	FIXME
	+
	+
	+	===== realpath() =====
	+
	+	realpath() - Extrahiert alle symbolische Links und löst Referenzen zu %%/./%%, %%/../%% und extra %%'/'%%-Symbole auf in einen Null-terminierten String (wandelt in die Form "canonicalized absolute pathname").
	+
	+	<code c>
	+	#include <limits.h>
	+	#include <stdlib.h>
	+
	+	char realpath(const char path, char *resolved_path);
	+	</code>
	+
	+	Quelle: [[http://man7.org/linux/man-pages/man3/realpath.3.html]]
	+
	+	===== dirname() und basename() =====
	+
	+	Das sind Funktionen um Pfade zu parsen.
	+
	+	<code c>
	+	#include <libgen.h>
	+
	+	char dirname(char path);
	+	char basename(char path);
	+	</code>
	+
	+	Die Funktionen dirname() and basename() zerlegen den Null-terminierten String in Directory und Filename.
	+
	+	Zusammensetzung des Ergebnisses von dirname(), "/" und des Ergebnisses von basename() ergibt den kompletten String für Directory/Filename.
	+
	+	Folgendes Beispiel zeigt es anschaulich:
	+
	+	^path ^dirname()^basename() ^
	+	\|"/usr/lib" \|"/usr" \|"lib" \|
	+	\|"/usr/" \|"/" \|"usr" \|
	+	\|"usr" \|"." \|"usr" \|
	+	\|"/" \|"/" \|"/" \|
	+	\|"." \|"." \|"." \|
	+	\|".." \|"." \|".." \|
	+
	+	===== opendir() =====
	+
	+	FIXME
	+
	+	[[EDV:OS:UNIX:Derivate:AIX]]: [[https://www.ibm.com/support/knowledgecenter/ssw_aix_61/com.ibm.aix.basetrf1/opendir.htm?lang=de]] (zur Struktur [[https://www.ibm.com/support/knowledgecenter/ssw_aix_61/com.ibm.aix.files/dir.htm?lang=de\|"struct direct"]])\\ oder [[https://www.ibm.com/support/knowledgecenter/ssw_aix_72/com.ibm.aix.basetrf1/opendir.htm]]
	+
	+	===== readdir() und readdir_r() =====
	+
	+	FIXME
	+
	+	Linux: [[http://man7.org/linux/man-pages/man3/readdir.3.html]]\\
	+	[[EDV:OS:UNIX:Derivate:AIX]]: [[https://www.ibm.com/support/knowledgecenter/ssw_aix_61/com.ibm.aix.basetrf2/readdir_r.htm?lang=de]]\\ oder [[https://www.ibm.com/support/knowledgecenter/ssw_aix_72/com.ibm.aix.basetrf2/readdir_r.htm?lang=de]]\\
	+	[[EDV:OS:UNIX:Derivate:Solaris]]: [[http://www.manpages.info/sunos/readdir.3.html]]\\ oder [[https://docs.oracle.com/cd/E19455-01/806-0627/6j9vhfn49/index.html]]
	+
	+	%%struct dirent%%: [[http://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html]]
	+	* Hinweis in Zusammenhan mit %%struct dirent%% und %%NAME_MAX%%: [[http://www.gnu.org/software/libc/manual/html_node/Reading_002fClosing-Directory.html#Reading_002fClosing-Directory]] (s. %%union%%)
	+
	+
	+	Windows stellt andere Funktionen zur Verfügung, die dem gleichen Zweck dienen: FindFirstFile(), FindNextFile() und FindClose():\\ [[https://msdn.microsoft.com/en-us/library/windows/desktop/aa364418%28v=vs.85%29.aspx]]
	+
	+	===== fnmatch() =====
	+
	+	Falls die File-/Ordner-Namen nach //pattern// gesucht werden, läßt sich mit der fnmatch() feststellen, ob der gefundene Eintrag dem vorgegebenen Muster entspricht.
	+
	+	FIXME
	+
	+	[[http://man7.org/linux/man-pages/man3/fnmatch.3.html]]
	+
	+
	+	===== closedir() =====
	+
	+	FIXME
	+
	+	----
	+	Stand: 23.05.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF