JK-Wiki edv:prg:cpp:example

edv:prg:cpp:example:aktuellen_timestamp_erfassen

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== Aktuellen Timestamp erfassen ======

	+	Als Beispiel eine Funktion, die die aktuelle Zeit erfaßt und über Parameter formatiert zurück gibt:
	+
	+	<code c>
	+	void getCurrentDateAndTime (string& currentDate, string& currentTime)
	+	{
	+	time_t now_global = time(0); // aktuelle Zeit ermitteln
	+	tm ltm;
	+	tm now_local;
	+	localtime_s(&ltm, &now);
	+	localtime_s(&now_local, &now_global);
	+
	+	char date[11]; // Im Format: "2015-12-31"
	+	sprintf_s(date, "%04i-%02i-%02i", now_local.tm_year + 1900, now_local.tm_mon, now_local.tm_mday);
	+
	+	currentDate = date;
	+
	+	char time[12]; // Im Format: "23-59-59-00"
	+	sprintf_s(time, "%02i-%02i-%02i-%02i", now_local.tm_hour, now_local.tm_min, now_local.tm_sec, 0);
	+
	+	currentTime = time;
	+	} // getCurrentDateAndTime()
	+	</code>
	+
	+	Hier sind weitere Infos zu den [[EDV:PRG:C:Tipp:Zeit-Funktionen]] zu finden.
	+
	+	----
	+	Stand: 05.07.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:auf_der_kommandozeile_uebergebene_parameter_parsen

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== Auf der Kommandozeile übergebene Parameter parsen ======

	+	Mit dem STL-Template std::vector<> ist das "Parsen" der Kommandozeile recht einfach:
	+
	+	<code cpp>
	+	int main(int argc, char* argv[])
	+	{
	+	int skip = 1; // Parameterliste ohne das Programm selbst: skip = 1, sonst (mit dem Programm): skip = 0;
	+
	+	auto args = std::vector<string>(argv + skip, argv + argc);
	+
	+	return 0;
	+	} // getCurrentDateAndTime()
	+	</code>
	+
	+	Danach sind alle Parameter einzeln (jeweils in einem string) im vector untergebracht.
	+
	+	----
	+	Stand: 17.03.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:export_von_funktionen_in_den_libraries

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== Export von Funktionen in den Libraries ======

	+	Unter Windows würde man die zu exportierenden Funktionen einfach in einem h-File (beispielsweise "dlldeclare.h" genannt) zusammenfassen und dabei mit den Deklarationen "%%__declspec(dllexport)%%" und "%%__declspec(dllimport)%%" versehen.\\ Ein Beispiel dafür ist unter [[EDV:PRG:CPP:Example:Export von Klassen/Strukturen/Methoden/Funktionen, die STL-Objekte (oder Templates allgemein) als Member/Parameter verwenden]] zu finden.
	+
	+	Auf Posix-Systemen erfolgt der Export von Funktionen (was im Endeffekt die Steuerung von Sichtbarkeit deren ist) durch die Zuweisung von Attributen an die betroffenen Funktionen.\\ Mehr zu den Attributen von Funktionen ist auf der GCC-Seite zu lesen: [[https://gcc.gnu.org/onlinedocs/gcc-4.8.1/gcc/Function-Attributes.html]] (en)
	+
	+	Eine detaillierte Beschreibung zum Thema Export gibt es ebenfalls auf der GCC-Seite: [[https://gcc.gnu.org/wiki/Visibility]] (en)
	+
	+	Unter [[https://www.akkadia.org/drepper/dsohowto.pdf]] (en) findet man eine Anleitung von Ulrich Drepper (führender Betreuer von GNU glibc), wie man Shared Libraries richtig schreibt.
	+
	+	FIXME
	+
	+	----
	+	Stand: 14.04.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:export_von_klassen_strukturen_methoden_funktionen_die_stl-objekte_oder_templates_allgemein_als_member_parameter_verwenden

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== Export von Klassen/Strukturen/Methoden/Funktionen, die STL-Objekte (oder Templates allgemein) als Member/Parameter verwenden ======

	+	:!: Im Folgenden beschriebene Vorgehensweise bezieht sich eher auf Windows.\\ Auf POSIX-Systemen ist die Vorgehenweise ein wenig anderes: [[EDV:PRG:CPP:Example:Export von Funktionen in den Libraries]]
	+
	+	Wenn man (z.B. in einer DLL) Klassen/Strukturen/Methoden/Funktionen exportiert, verwendet man entweder das def-File (i.d.R. für die C-Funktionen), oder das Schlüsselwort %%__declspec(dllexport)%% bei der Deklaration (i.d.R. für die C++-Funktionen). Mit dem Schlüsselwort %%__declspec(dllimport)%% werden diese in der Anwendung importiert.
	+
	+	Beispiel für das def-File "meinewunderlib.def":
	+
	+	<code text>
	+	LIBRARY meinewunderlib
	+
	+	EXPORTS
	+
	+	; meinewunderlib calls
	+	MWLCONN
	+	MWLDISC
	+	MWLOPEN
	+	MWLCLOSE
	+	MWLPUT
	+	MWLGET
	+	MWLCMIT
	+	MWLBACK
	+
	+	; management
	+	MWL_PING
	+	MWL_RESET
	+	MWL_EXCHANGE_INFORMATION
	+
	+	; debug
	+	MWL_DBGLOG_SETCALLBACK
	+	MWL_DBGLOG_SETLOGLEVEL
	+
	+	; misc
	+	DllMain
	+	</code>
	+
	+	Die Deklarationen mittels "%%__declspec(dllexport)%%" und "%%__declspec(dllimport)%%" nimmt man normaleweise über Defines mit sprechenden Namen vor, hier "MEINEWUNDERLIB_DLL_API":
	+
	+	<code cpp>
	+	class MEINEWUNDERLIB_DLL_API informationprovider
	+	{
	+	public:
	+	informationprovider(const string& name, exchange_information_callback_t exchange_information);
	+	~informationprovider();
	+
	+	void exchange_information(const string& command, const std::map<string, string>& in, std::map<string, string>& out);
	+
	+	struct MEINEWUNDERLIB_DLL_API commands
	+	{
	+	public:
	+	static const char* GET_STATISTICS;
	+	static const char* GET_INFORMATION;
	+	static const char* CLEAR_STATISTICS;
	+	};
	+	};
	+	</code>
	+
	+	Da die Parameter "in" und "out" in der "exchange_information()" vom Typ "std::map<string, string>" sind, das wiederum ein STL-Template ist, soll dieses Template für den Export ebenfalls angemeldet werden. Sonst würde der Compiler nach der Auflösung von Templates für eben diese neue, für diese Library spezifische, Typennamen generiern. Wenn die Anwendung, die später diese Library importiert, die gleichen Templates (mit der gleichen Typenzuweisung) verwendet, würde der Compiler für sie ebenfalls Typennamen (für die Anwendung spezifische) generieren. Dadurch würden für den selben Typ zwei unterschiedliche Namen entstehen, was der Linker konsequenterweise als zwei unterschiedliche Typen interpretiert. Damit das nicht passiert, exportiert man auch die verwendeten Templates.
	+
	+	Dafür setzt man vor der Klassendeklaration (hier vor der Klasse "informationprovider") den Export des Templates:
	+
	+	<code cpp>
	+	MEINEWUNDERLIB_DLL_API__STL_TEMPLATE_CLASS std::map < string, string > ;
	+	</code>
	+
	+	Alle Export-Deklaration kann man in einem h-File (beispielsweise "dlldeclare.h" genannt) zusammenfassen:
	+
	+	<code cpp>
	+	#ifdef MEINEWUNDERLIB_DLLEXPORT
	+
	+	#define MEINEWUNDERLIB_DLL_API __declspec(dllexport)
	+	#define MEINEWUNDERLIB_TEMPLATE
	+
	+	#else
	+
	+	#define MEINEWUNDERLIB_DLL_API __declspec(dllimport)
	+	#define MEINEWUNDERLIB_TEMPLATE
	+
	+	#pragma comment( lib, "meinewunderlib" )
	+
	+	#endif
	+
	+	// STL-klassen für DLL-export anmelden; https://support.microsoft.com/en-us/kb/168958
	+	#define MEINEWUNDERLIB_DLL_API__STL_TEMPLATE_STRUCT MEINEWUNDERLIB_TEMPLATE template struct MEINEWUNDERLIB_DLL_API
	+	#define MEINEWUNDERLIB_DLL_API__STL_TEMPLATE_CLASS MEINEWUNDERLIB_TEMPLATE template class MEINEWUNDERLIB_DLL_API
	+	#define MEINEWUNDERLIB_DLL_API__STL_CLASS MEINEWUNDERLIB_TEMPLATE class MEINEWUNDERLIB_DLL_API
	+	</code>
	+
	+	Ausführliche Infos dazu findet man auf der Microsoft-Seite: [[https://support.microsoft.com/en-us/kb/168958]] (Artikel "How to export an instantiation of a Standard Template Library (STL) class and a class that contains a data member that is an STL object")
	+
	+	----
	+	Stand: 22.03.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:fileutils

Anonymous (anonymous@undisclosed.example.com) — 2020-01-21T17:26:41+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Fileutils ======

	+	===== Beispiel 1 - TextFile lesen =====
	+
	+	Als Beispiel eine Klasse, die die Fileoperationen behandelt:
	+
	+	fileutils.h
	+	<code cpp>
	+	namespace utils
	+	{
	+	class fileutils
	+	{
	+	public:
	+	fileutils(const fileutils&) = delete;
	+	fileutils& operator=(const fileutils&) = delete;
	+
	+	public:
	+	static const string ASCII;
	+
	+	public:
	+	static string read_file_content(const string& filePath); // liefert den inhalt der datei
	+	static time_t get_timestamp(const string& filePath); // liefert den zeitstempel der datei (sekundengenau)
	+	static int get_file_size(const string& filePath); // liefert die dateigröße
	+	static bool exists(const string& filePath);
	+	static string get_bom_encoding(const string& content);
	+	}; // class fileutils
	+
	+	inline bool fileutils::exists(const string& filePath) { return get_file_size(filePath) >= 0; }
	+	} // namespace utils
	+	</code>
	+
	+	fileutils.cpp
	+	<code cpp>
	+	namespace utils
	+	{
	+	const string fileutils::ASCII = "ascii";
	+
	+	string fileutils::read_file_content(const string& filePath)
	+	{
	+	std::ifstream ifs(filePath);
	+	string content((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
	+	return content;
	+	}
	+
	+	time_t fileutils::get_timestamp(const string& filePath)
	+	{
	+	struct stat stat_buf;
	+	int rc = stat(filePath.c_str(), &stat_buf);
	+	if (rc == 0)
	+	return stat_buf.st_mtime;
	+	return 0;
	+	}
	+
	+	int fileutils::get_file_size(const string& filePath)
	+	{
	+	struct stat stat_buf;
	+	int rc = stat(filePath.c_str(), &stat_buf);
	+	if (rc == 0)
	+	return stat_buf.st_size;
	+	return -1; // not found
	+	}
	+
	+	string fileutils::get_bom_encoding(const string& content)
	+	{
	+	// http://de.wikipedia.org/wiki/Byte_Order_Mark
	+
	+	const char* ENCODING_NAME[] =
	+	{
	+	"UTF-EBCDIC",
	+	"UTF-32 (BE)",
	+	"UTF-32 (LE)",
	+	"UTF-7",
	+	"UTF-7",
	+	"UTF-7",
	+	"UTF-7",
	+	"UTF-8",
	+	"UTF-1",
	+	"UTF-16 (BE)",
	+	"UTF-16 (LE)",
	+	nullptr
	+	};
	+	const char* ENCODING_BOM[] =
	+	{
	+	"\xDD\x73\x66\x73",
	+	"\x00\x00\xFE\xFF",
	+	"\xFF\xFE\x00\x00",
	+	"\x2B\x2F\x76\x38",
	+	"\x2B\x2F\x76\x39",
	+	"\x2B\x2F\x76\x2B",
	+	"\x2B\x2F\x76\x2F",
	+	"\xEF\xBB\xBF",
	+	"\xF7\x64\x4C",
	+	"\xFE\xFF",
	+	"\xFF\xFE",
	+	nullptr
	+	};
	+	const size_t ENCODING_BOM_LEN[] =
	+	{
	+	4,
	+	4,
	+	4,
	+	4,
	+	4,
	+	4,
	+	4,
	+	3,
	+	3,
	+	2,
	+	2,
	+	0
	+	};
	+
	+	for (int i = 0; ENCODING_BOM_LEN[i] != 0; ++i)
	+	{
	+	auto len = ENCODING_BOM_LEN[i];
	+	if (content.length() >= len)
	+	{
	+	if (strncmp(content.c_str(), ENCODING_BOM[i], len) == 0)
	+	{
	+	return ENCODING_NAME[i];
	+	}
	+	}
	+	}
	+	return fileutils::ASCII;
	+	}
	+	} // namespace utils
	+	</code>
	+
	+
	+	===== Beispiel 2 - TextFile schreiben =====
	+
	+	Text in ein File ausgeben:
	+
	+	<code cpp>
	+	void IrgendEineClasse::create_text_file(const char* content)
	+	{
	+	string file_name = get_filename();
	+	std::ofstream textFile(file_name);
	+	textFile << content;
	+	}
	+	</code>
	+
	+
	+	----
	+	Stand: 21.01.2020\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:initialisierung_eines_objekts_bei_dessen_deklaration

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== Initialisierung eines Objekts bei dessen Deklaration ======

	+	Bei der Deklaration eines Objekts mit gleichzeitiger Initialisierung kommt gelegentlich (zumindest beim Kompilieren mit GCC) zu den (auf den ersten Blick) seltsamen Fehlermeldungen.
	+
	+	Ein Beispiel:
	+
	+	<code cpp>
	+	void eine_klasse::eine_methode(const string& filepath)
	+	{
	+	auto file = std::ofstream(filepath, std::ios_base::trunc);
	+
	+	file << "Hier wird irgendwas in das File geschrieben...";
	+
	+	file << std::endl;
	+	}
	+	</code>
	+
	+	Hier wird das Objekt file deklariert und gleich durch den Konstruktor //ofstream(const string& filename, ios_base::openmode mode = ios_base::out)// (C++11) initialisiert. Der GNU-Compiler erzeugt dabei ein temporäres Objekt und ruft anschließend den Copy-Constructor //ofstream(const ofstream&)// des zu erzeugendes Objekts auf. Der ist jedoch in der STL als deleted definiert (Quelle: [[http://www.cplusplus.com/reference/fstream/ofstream/ofstream/]]):
	+
	+	<code cpp>
	+	// default (1)
	+	ofstream();
	+	// initialization (2)
	+	explicit ofstream (const char* filename, ios_base::openmode mode = ios_base::out);
	+	explicit ofstream (const string& filename, ios_base::openmode mode = ios_base::out);
	+	// copy (3)
	+	ofstream (const ofstream&) = delete;
	+	// move (4)
	+	ofstream (ofstream&& x);
	+	</code>
	+
	+	Der Compiler beschwert sich dabei:
	+
	+	<code>
	+	ein_file.cpp: In member function 'void eine_klasse::eine_methode(const string&)':
	+	ein_file.cpp:127:69: error: use of deleted function 'std::basic_ofstream<char>::basic_ofstream(const std::basic_ofstream<char>&)'
	+	auto file = std::ofstream(filepath, std::ios_base::trunc);
	+	^
	+	</code>
	+
	+	Beim genaueren Hinsehen fällt auf, dass die als //deleted// angegebene Funktion nicht die ist, die man erwartet (s. die nächste Zeile).
	+
	+	Abhilfe schafft man, wenn man explizit den Konstruktor des zu erzeugendes Objekts aufruft:
	+
	+	<code cpp>
	+	void eine_klasse::eine_methode(const string& filepath)
	+	{
	+	std::ofstream file(filepath, std::ios_base::trunc);
	+	}
	+	</code>
	+
	+	----
	+	Stand: 29.02.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:initialisierung_und_deinitialisierung_von_dynamischen_libraries

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== Initialisierung und Deinitialisierung von dynamischen Libraries ======

	+	Beim Laden/Entladen einer dynamischen Library besteht häufig Notwendigkeit, einige Funktionen automatisiert auszuführen. Beim Laden z.B. müssen globale Variablen initialisiert werden (davon abgesehen, dass globale Variablen in einer Library möglichst zu vermeiden sind). Beim Entladen z.B. müssen irgendwelche Aufräumarbeiten durchgeführt werden (z.B. Schließen von Logfiles).
	+
	+	:!: Diese Notwendigkein besteht insbesondere dann, wenn die dynamischen Library nicht zur Laufzeit des Programms geladen werden (dlopen() unter Linux bzw. LoadLibrary() unter Windows), sondern wenn sie gleich beim Starten des Programms durch den Betriebssystem-Loader gelinkt werden. In diesem Fall sind die Libraries bereits geladen, bevor die main()-Funktion die Kontrolle übernimmt. Die Initialisierungs-Funktion wird in diesem Fall ebenfalls vor und die Deinitialisierungs-Funktion nach der main()-Funktion aufgerufen (wenn die main() durch return() oder exit() bereits die Kontrolle abgegeben hat).
	+
	+	Es gibt verschiedene Mechanismen, dies zu realisieren.
	+
	+	===== Unix- / GCC-Variante =====
	+
	+	Man exportiert mittels %%__attribute__(())%% Funktionen zum Initialisieren und Finalisieren der Library:
	+
	+	<code c>
	+	void __attribute__ ((constructor)) lib_initialize(void);
	+	void __attribute__ ((destructor)) lib_finalize(void);
	+
	+	// Called when the library is loaded and before dlopen() returns.
	+	void lib_initialize(void)
	+	{
	+	// Lib-initialization code here.
	+	}
	+
	+	// Called when the library is unloaded and before dlclose() returns.
	+	void lib_finalize(void)
	+	{
	+	// Clean-up code here.
	+	}
	+	</code>
	+
	+	In der veralteten Variante lauten diese Symbole _init() bzw. _fini() - die sind //deprecated// und sollen daher nicht mehr benutzt werden.
	+
	+	:!: Shared Libraries sollen nicht mit dem GCC Schalter -nostartfiles oder -nostdlib kompiliert/gelinkt werden! Durch diese Parameter werden die Constructor/Destructor-Routinen unterdrückt!
	+
	+	Links:
	+	* Linux Programmer's Manual: [[http://man7.org/linux/man-pages/man3/dlopen.3.html]] (unter //"Initialization and finalization functions"//)
	+	* The Linux Dokumentation Project: [[http://tldp.org/HOWTO/Program-Library-HOWTO/miscellaneous.html]] (unter //"Library constructor and destructor functions"//)
	+	* Implementing DllMain in a linux shared library: [[http://tdistler.com/2007/10/05/implementing-dllmain-in-a-linux-shared-library]]
	+	* Automatically executed functions when loading shared libraries: [[http://stackoverflow.com/questions/9759880/automatically-executed-functions-when-loading-shared-libraries]]
	+
	+	Solaris Compiler nutzen %%#pragma init%% and %%#pragma fini%% für diesen Zweck:
	+
	+	<code c>
	+	#pragma init(lib_initialize)
	+	#pragma fini(lib_finalize)
	+
	+	void lib_initialize(void)
	+	{
	+	// ...
	+	}
	+
	+	void lib_finalize(void)
	+	{
	+	// ...
	+	}
	+	</code>
	+
	+
	+	===== Windows =====
	+
	+	<code c>
	+	// Return TRUE on success and FALSE if an error occurs. Returning FALSE will cause the library to be unloaded.
	+	BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
	+	{
	+	switch (fdwReason)
	+	{
	+	case DLL_PROCESS_ATTACH:
	+	// Lib-initialization code here.
	+	break;
	+	case DLL_PROCESS_DETACH:
	+	// Clean-up code here.
	+	break;
	+	}
	+
	+	return(TRUE);
	+	}
	+	</code>
	+
	+	Links:
	+	* DllMain entry point: [[https://msdn.microsoft.com/en-us/library/ms682583.aspx]]
	+
	+
	+	----
	+	Stand: 11.04.2016
	+
	+	EOF

edv:prg:cpp:example:spontan_auf_eine_dynamische_library_zugreifen

Anonymous (anonymous@undisclosed.example.com) — 2024-04-09T13:24:58+00:00

1578702200		aktuell
Zeile 1:		Zeile 1:
-	====== Fileutils ======	+	====== "Spontan" auf eine dynamische Library zugreifen ======

	Ein Beispiel, wie man auf eine dynamische Library dynamisch zugreift - ohne sie vorher durch den Linker in das Programm eingebunden zu haben. Die DLL/SharedObject wird zur Laufzeit dynamisch geladen, genutzt und dann wieder aus dem Speicher entladen.		Ein Beispiel, wie man auf eine dynamische Library dynamisch zugreift - ohne sie vorher durch den Linker in das Programm eingebunden zu haben. Die DLL/SharedObject wird zur Laufzeit dynamisch geladen, genutzt und dann wieder aus dem Speicher entladen.

edv:prg:cpp:example:static_assert

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== static_assert() ======

	+	Mit static_assert() wird ein konstanter Ausdruck (zwischen den Klammern) zur Übersetzungszeit überprüft. Gibt die Auswertung nicht true zurük, bricht der Compiler ab.
	+
	+	Beispiel:
	+
	+	<code c++>
	+	//
	+
	+	static_assert(sizeof(long double) == 16, "FEHLER: Es wird 16 Byte long double erwartet.");
	+
	+	//
	+	</code>
	+
	+	Auf Systemen, die bei long double eine andere Größe haben, als 16, wird der Compiler mit der o.g. Fehlermeldung abbrechen.
	+
	+	----
	+	Stand: 14.10.2014
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:stringutils

Anonymous (anonymous@undisclosed.example.com) — 2020-01-21T14:28:39+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Stringutils ======

	+	Helper rund um die Strings.
	+
	+	stringutils.h
	+	<code cpp>
	+	#ifdef OS_WINDOWS
	+	#define STRING_COMPARE_IGNORE_CASE _stricmp
	+	#else
	+	#define STRING_COMPARE_IGNORE_CASE strcasecmp
	+	#endif // #ifdef OS_WINDOWS
	+
	+	namespace utils
	+	{
	+	class stringutils // Helper rund um die Strings.
	+	{
	+	public:
	+	stringutils() = delete;
	+	~stringutils() = delete;
	+
	+	public:
	+	static const char* const WHITESPACE;
	+	static const char* const EMPTY;
	+
	+	public:
	+	static const string::size_type npos; // Ersatz für "string::npos", welches wegen des DLL-Imports/Link-Problemen nicht verwendet werden kann.
	+
	+	public:
	+	static std::vector<string> split_lines(const string &s); // Trennt den String nach Zeilen.
	+	static std::vector<string> split(const string &s, char delim, int count = INT_MAX); // Trennt den String nach dem Zeichen.
	+
	+	static string trim(const string& s, const char* trimChars = nullptr); // Schneidet Leerzeichen links und rechts ab.
	+	static string trim_left(const string& s, const char* trimChars = nullptr); // Schneidet Leerzeichen links ab.
	+	static string trim_right(const string& s, const char* trimChars = nullptr); // Schneidet Leerzeichen rechts ab.
	+
	+	static string pad_right(const string& s, char c); // Hängt ein Zeichen an, wenn es noch nicht vorhanden ist.
	+	static string pad_right(const string& s, size_t size, const char c = ' '); // Ergänzt fehlendes Padding.
	+	static string pad_left(const string& s, char c); // Ergänzt ein Zeichen links, wenn es noch nicht vorhanden ist.
	+	static string pad_left(const string& s, size_t size, const char c = ' '); // Ergänzt fehlendes Padding links.
	+
	+	static string to_upper(const string &s); // Wandelt den String in Grossbuchstaben um.
	+
	+	static string replace(const string &s, const string &old, const string &newText); // Ersetzt Teilstrings durch neue Strings.
	+	static int compare_nocase(const string &s1, const string &s2);
	+
	+	private:
	+	static std::vector<string>& split(const string &s, char delim, std::vector<string> &elems, int count);
	+	static std::vector<string>& split_lines(const string &s, std::vector<string> &elems);
	+	}; // class stringutils
	+
	+	// --- inlines ---
	+
	+	inline std::vector<string> stringutils::split(const string &s, char delim, int count)
	+	{
	+	std::vector<string> elems;
	+	split(s, delim, elems, count);
	+	return elems;
	+	} // split()
	+
	+	inline std::vector<string> stringutils::split_lines(const string &s)
	+	{
	+	std::vector<string> elems;
	+	split_lines(s, elems);
	+	return elems;
	+	} // split_lines()
	+
	+	inline string stringutils::trim_left(const string& s, const char* trimChars)
	+	{
	+	size_t startpos = s.find_first_not_of(trimChars ? trimChars : WHITESPACE);
	+	return (startpos == string::npos) ? EMPTY : ((startpos == 0) ? s : s.substr(startpos));
	+	} // trim_left()
	+
	+	inline string stringutils::trim_right(const string& s, const char* trimChars)
	+	{
	+	size_t endpos = s.find_last_not_of(trimChars ? trimChars : WHITESPACE);
	+	return (endpos == string::npos) ? EMPTY : ((endpos == s.length() - 1) ? s : s.substr(0, endpos + 1));
	+	} // trim_right()
	+
	+	inline string stringutils::trim(const string& s, const char* trimChars)
	+	{
	+	size_t startpos = s.find_first_not_of(trimChars ? trimChars : WHITESPACE);
	+	if (startpos == string::npos)
	+	return EMPTY;
	+	size_t endpos = s.find_last_not_of(trimChars ? trimChars : WHITESPACE);
	+	if ((startpos == 0) && (endpos == s.length() - 1))
	+	return s;
	+	return s.substr(startpos, endpos - startpos + 1);
	+	} // trim()
	+
	+	inline string stringutils::pad_right(const string& s, char c)
	+	{
	+	if (s.empty())
	+	return s;
	+	if (s[s.length() - 1] == c)
	+	return s;
	+	return s + c;
	+	} // pad_right()
	+
	+	inline string stringutils::pad_right(const string& s, size_t size, char c)
	+	{
	+	if (s.length() >= size)
	+	return s;
	+	string ss = s;
	+	ss.resize(size, c);
	+	return ss;
	+	} // pad_right()
	+
	+	inline string stringutils::pad_left(const string& s, char c)
	+	{
	+	if (s.empty())
	+	return s;
	+	if (s[0] == c)
	+	return s;
	+	return c + s;
	+	} // pad_left()
	+
	+	inline string stringutils::pad_left(const string& s, size_t size, char c)
	+	{
	+	if (s.length() >= size)
	+	return s;
	+	return string(size - s.length(), c) + s;
	+	} // pad_left()
	+
	+	inline string stringutils::to_upper(const string &s)
	+	{
	+	string t = s;
	+	#ifdef OS_UNIX_AIX
	+	std::transform(t.begin(), t.end(), t.begin(), (int (*)(int))std::toupper);
	+	#else
	+	std::transform(t.begin(), t.end(), t.begin(), ::toupper);
	+	#endif
	+	return t;
	+	} // to_upper()
	+
	+	inline int stringutils::compare_nocase(const string &s1, const string &s2)
	+	{
	+	return STRING_COMPARE_IGNORE_CASE(s1.c_str(), s2.c_str());
	+	} // compare_nocase()
	+	} // namespace utils
	+	// EOF
	+	</code>
	+
	+
	+	stringutils.cpp
	+	<code cpp>
	+	namespace utils
	+	{
	+	const char* const stringutils::WHITESPACE = " \n\r\t";
	+	const char* const stringutils::EMPTY = "";
	+	const string::size_type stringutils::npos = string::npos;
	+
	+	std::vector<string>& stringutils::split(const string &s, char delim, std::vector<string> &elems, int count)
	+	{
	+	const char* current = s.c_str();
	+	const char* to;
	+	int cnt = 0;
	+
	+	while (current != nullptr)
	+	{
	+	++cnt;
	+	if (cnt >= count)
	+	{
	+	to = nullptr;
	+	}
	+	else
	+	{
	+	to = strchr(current, delim);
	+	}
	+	if (to == nullptr)
	+	{
	+	elems.push_back(current);
	+	break;
	+	}
	+	elems.push_back(string(current, to));
	+	current = to + 1;
	+	}
	+	return elems;
	+	} // split()
	+
	+	std::vector<string>& stringutils::split_lines(const string &s, std::vector<string> &elems)
	+	{
	+	std::stringstream ss(s);
	+	string item;
	+	while (std::getline(ss, item))
	+	elems.push_back(item);
	+	return elems;
	+	} // split_lines()
	+
	+	string stringutils::replace(const string &s, const string &old, const string &newText)
	+	{
	+	string result = s;
	+	auto len = old.length();
	+	auto pos = result.find(old);
	+	while (pos != string::npos)
	+	{
	+	result.replace(pos, len, newText);
	+	pos = result.find(old);
	+	}
	+	return result;
	+	} // replace()
	+	} // namespace utils
	+	// EOF
	+	</code>
	+
	+	----
	+	Stand: 30.10.2018\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:trim

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== Trim ======

	+	Führende Leerzeichen entfernen:
	+
	+	<code cpp>
	+	zuTrimmendeString.erase(0, zuTrimmendeString.find_first_not_of(" "));
	+	</code>
	+
	+	Leerzeichen am Ende entfernen:
	+
	+	<code cpp>
	+	zuTrimmendeString.erase(zuTrimmendeString.find_last_not_of(" ") + 1);
	+	</code>
	+
	+	Auf beiden Seiten:
	+
	+	<code cpp>
	+	posBegin = zuTrimmendeString.find_first_not_of(" ");
	+	posEnd = zuTrimmendeString.find_last_not_of(" ");
	+	zuTrimmendeString = zuTrimmendeString.substr(posBegin, posEnd - posBegin + 1);
	+	</code>
	+
	+	Oder als Klasse mit statischen Methoden (hier nur ein Ausschnitt):
	+
	+	<code cpp>
	+	class stringutils
	+	{
	+	private:
	+	static const char* const WHITESPACE;
	+	static const char* const EMPTY;
	+
	+	public:
	+	static const string::size_type npos;
	+
	+	public:
	+	static string trim (const string& s, const char* trimChars = nullptr);
	+	static string trim_left (const string& s, const char* trimChars = nullptr);
	+	static string trim_right(const string& s, const char* trimChars = nullptr);
	+	};
	+
	+
	+	const char* const stringutils::WHITESPACE = " \n\r\t";
	+	const char* const stringutils::EMPTY = "";
	+	const string::size_type stringutils::npos = string::npos;
	+
	+
	+	inline string stringutils::trim_left(const string& s, const char* trimChars)
	+	{
	+	size_t startpos = s.find_first_not_of(trimChars ? trimChars : WHITESPACE);
	+	return (startpos == string::npos) ? EMPTY : ((startpos == 0) ? s : s.substr(startpos));
	+	}
	+
	+	inline string stringutils::trim_right(const string& s, const char* trimChars)
	+	{
	+	size_t endpos = s.find_last_not_of(trimChars ? trimChars : WHITESPACE);
	+	return (endpos == string::npos) ? EMPTY : ((endpos == s.length() - 1) ? s : s.substr(0, endpos + 1));
	+	}
	+
	+	inline string stringutils::trim(const string& s, const char* trimChars)
	+	{
	+	size_t startpos = s.find_first_not_of(trimChars ? trimChars : WHITESPACE);
	+	if (startpos == string::npos) return EMPTY;
	+	size_t endpos = s.find_last_not_of(trimChars ? trimChars : WHITESPACE);
	+	if ((startpos == 0) && (endpos == s.length() - 1)) return s;
	+	return s.substr(startpos, endpos - startpos + 1);
	+	}
	+	</code>
	+
	+	In der [[http://www.boost.org/\|Boost]]-Library ist diese Funktionalität bereits enthalten.
	+
	+	----
	+	Stand: 02.06.2015\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:xxxxxx_s

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== xxxxxx_s()-Funktionen ======

	+	In einigen Libraries fehlen ein paar Funktionen, die dort laut Doku eigentlich vorhanden sein sollten.
	+
	+	Konkrett, auf einem RHEL 2.6.32-504.3.3.el6.x86_64 mit der GCC 4.9.2 waren die memcpy_s(), strcpy_s(), strncpy_s() und einige andere Funktionen nicht in den Bibliotheken enthalten.
	+
	+	Sie können jedoch wie folgt selbst nachgebaut werden:
	+
	+	<code c>
	+	#include <memory.h>
	+	#include <errno.h>
	+	typedef error_t errno_t;
	+	inline errno_t memcpy_s(void dest, size_t numberOfElements, const void src, size_t count) { if (!dest) return EINVAL; memset(dest, 0, sizeof(char)); if (!src) return EINVAL; if (numberOfElements < count) return ERANGE; memcpy(dest, src, count); return 0; }
	+
	+	template <size_t size>
	+	inline errno_t strcpy_s(char (&dest)[size], const char *src) { size_t srcLen = 0; if (!dest) return EINVAL; dest[0] = '\0'; if (!src) return EINVAL; srcLen = strlen(src); if (size < srcLen + 1) return ERANGE; strncpy(dest, src, size); dest[srcLen] = '\0'; return 0; }
	+
	+	inline errno_t strncpy_s(char dest, size_t numberOfElements, const char src, size_t count) { if (!dest) return EINVAL; if (numberOfElements == 0) return EINVAL; dest[0] = '\0'; if (!src) return EINVAL; if (numberOfElements < count + 1) return ERANGE; strncpy(dest, src, count); dest[count] = '\0'; return 0; }
	+	</code>
	+
	+	:!: Achtung!\\ Diese Implementierung entspricht nicht 100% den ofiziellen Quellen und nur als Workaround zu betrachten!\\ Insbesondere es wird kein Handler für ungültige Parameter aufgerufen, was bei den Originalfunktionen der Fall wäre!
	+
	+	----
	+	Stand: 21.06.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:cpp:example:zuweisung_eines_objekts_an_static_member_einer_klasse

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

	aktuell
Zeile 1:	Zeile 1:
	+	====== Zuweisung eines Objekts an Static Member einer Klasse ======

	+	Bei der Zuweisung eines Objekts an Static Member einer Klasse ist Vorsicht geboten!
	+
	+	Folgende Schreibweise ist zwar C++ konform:
	+
	+	<code cpp>
	+	std::atomic<uint64_t> connection::m_next_free_connhandle = 1;
	+	</code>
	+
	+	...für GCC muss jedoch wie folgt umgestellt werden:
	+
	+	<code cpp>
	+	std::atomic<uint64_t> connection::m_next_free_connhandle(1);
	+	</code>
	+
	+	GCC ruft sonst nicht den Konstruktor für den Static Member auf, sondern den Konstruktor für ein temporäres Objekt + den copy-Konstruktor. Und der ist bei manchen Klassen nicht vorhanden (selbst wenn, wäre das überflüssige Mehrarbeit).
	+
	+	----
	+	Stand: 12.02.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF