<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[C (alle ISO-Standards)]]></title><description><![CDATA[Fragen zu bestimmten Funktionen und Abläufen in C, basierend auf den Standards C89 (ANSI-C), C90, C99, C11 und C18. Benutzung der Standardlibs, Zeiger und Strings. Bitte keine Fragen zu Windows&#x2F;Linux oder C++!]]></description><link>https://www.c-plusplus.net/forum/category/25</link><generator>RSS for Node</generator><lastBuildDate>Sun, 08 Mar 2026 07:37:55 GMT</lastBuildDate><atom:link href="https://www.c-plusplus.net/forum/category/25.rss" rel="self" type="application/rss+xml"/><pubDate>Wed, 02 Jul 2025 02:52:28 GMT</pubDate><ttl>60</ttl><item><title><![CDATA[C Linkliste]]></title><description><![CDATA[sehr interessante liste.
wieso wurde der user gesperrt?
]]></description><link>https://www.c-plusplus.net/forum/topic/353442/c-linkliste</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/353442/c-linkliste</guid><dc:creator><![CDATA[Foulpelz]]></dc:creator><pubDate>Wed, 02 Jul 2025 02:52:28 GMT</pubDate></item><item><title><![CDATA[[Neu] Syntax Highlighting für C]]></title><description><![CDATA[Vielen Dank für Deine ausführliche Antwort!
]]></description><link>https://www.c-plusplus.net/forum/topic/310201/neu-syntax-highlighting-für-c</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/310201/neu-syntax-highlighting-für-c</guid><dc:creator><![CDATA[Swordfish]]></dc:creator><pubDate>Sat, 09 Jun 2018 15:35:01 GMT</pubDate></item><item><title><![CDATA[Linkliste für Neulinge]]></title><description><![CDATA[Leider etwas eingeschlafen und beileibe nicht zu 80% fertig: https://de.wikibooks.org/wiki/C-Programmierung
Aber für Anfänger gut verständlich gemacht.
]]></description><link>https://www.c-plusplus.net/forum/topic/300567/linkliste-für-neulinge</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/300567/linkliste-für-neulinge</guid><dc:creator><![CDATA[pointercrash**]]></dc:creator><pubDate>Tue, 06 Oct 2015 12:11:57 GMT</pubDate></item><item><title><![CDATA[RTFM! oder warum dir keiner helfen will...]]></title><description><![CDATA[c.rackwitz schrieb:

wenn deine(r) das nicht oder nicht ausreichend kann, besorg dir ein tool dafuer.
indent: http://www.linuxcommand.org/man_pages/indent1.html
dieses solltest du auf jedem unix finden. fuer windows kannst du auch einfach cygwin installieren (bei der installation &quot;indent&quot; mit anwaehlen).

Für Windows gibt es auch noch die unxutils, eine Sammlung von GNU tools für win32. Darin ist indent auch vertreten.
Ansonsten gibt es noch astyle, weniger mächtig, dafür vielleicht etwas einfacher.
]]></description><link>https://www.c-plusplus.net/forum/topic/136013/rtfm-oder-warum-dir-keiner-helfen-will</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/136013/rtfm-oder-warum-dir-keiner-helfen-will</guid><dc:creator><![CDATA[[[global:guest]]]]></dc:creator><pubDate>Fri, 24 Aug 2007 15:50:01 GMT</pubDate></item><item><title><![CDATA[C90: implizite Typwandlung double-&gt;int bei Zuweisung von int-Literalen?]]></title><description><![CDATA[@Yadgar sagte in C90: implizite Typwandlung double-&gt;int bei Zuweisung von int-Literalen?:

Und noch was: was bringt es eigentlich, in Funktionen den Rückgabewert nach return in Klammern zu schreiben?

Nichts, da es kein Funktionsaufruf ist. Man sollte es daher einfach weglassen. Was das Thema Floatingpoint Literale betrifft. Das wird dann ein Thema, wenn Du z.B.
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

int main() {
    double r1 = 1.0/3.0;
    double r2 = 1/3;

    printf(&quot;%f\n&quot;, r1);
    printf(&quot;%f\n&quot;, r2);

    return EXIT_SUCCESS;
}

schreibst. Für r2 wird nämlich eine Ganzzahldivision durchgeführt.
]]></description><link>https://www.c-plusplus.net/forum/topic/355369/c90-implizite-typwandlung-double-int-bei-zuweisung-von-int-literalen</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355369/c90-implizite-typwandlung-double-int-bei-zuweisung-von-int-literalen</guid><dc:creator><![CDATA[*john 0]]></dc:creator><pubDate>Fri, 03 Oct 2025 10:40:18 GMT</pubDate></item><item><title><![CDATA[C Werkstatt]]></title><description><![CDATA[Projekt /c/ stellt eine Werkstatt zum Entwickeln von C-Programmen. Die Tools in den Bibliotheken erleichtern die Programmentwicklung.
Alle Funktionen sind in freien statischen Bibliotheken abgelegt. Die Dokumentationen befinden sich in den Headerdateien. Testprogramme demonstrieren die Verwendung und Fehlerfreiheit der Funktionen.
Details findet man unter der Suche: &quot;schardinger projekt c&quot;
Servus, Günther
]]></description><link>https://www.c-plusplus.net/forum/topic/355366/c-werkstatt</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355366/c-werkstatt</guid><dc:creator><![CDATA[projektc]]></dc:creator><pubDate>Thu, 25 Sep 2025 16:51:46 GMT</pubDate></item><item><title><![CDATA[Umlaute in C]]></title><description><![CDATA[@Yadgar sagte in Umlaute in C:

Letzte Meldung: *john 0s Workaround mit den wide_chars funktioniert auch unter C90! Danke für den Tipp!

C95 existiert nicht – jedenfalls nicht offiziell. 1995 erschien das erste Amendment zur ISO Norm von 1990. Konforme Compiler mussten daher das Amendment 1 nachrüsten. 1999 erschien dann eine neu Version der Norm.
Wenn man aktuelle Compiler nutzt, und diese noch die alten Normen unterstützen, tun sie das natürlich so, dass sie die Amendments der jeweiligen Version unterstützen. Nutz man historische Compiler, dann muss man sehr genau darauf achten, was für einen technischen Stand sie unterstützen ISO/IEC 9899:1990 oder ISO/IEC 9899:1990/Amd1:1995.
Ungewöhnlich war, dass dieses Amendment Erweiterungen der Standardbibliothek vornahm. Üblicherweise werden in Amendments Fehler korrigiert, die über reine Schreibfehler hinausgehen.
]]></description><link>https://www.c-plusplus.net/forum/topic/355355/umlaute-in-c</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355355/umlaute-in-c</guid><dc:creator><![CDATA[*john 0]]></dc:creator><pubDate>Thu, 18 Sep 2025 07:45:08 GMT</pubDate></item><item><title><![CDATA[json-c array Sortieren]]></title><description><![CDATA[Das war der entscheidende Tip aber musste:
const json_object *pos_jso;

auf:
struct json_object *pos_jso;

ändern, dass das geht, hatte gestern Abend mir eine Umständliche Lösung gebaut und kam darauf:
#include &lt;stdio.h&gt;
#include &lt;json-c/json.h&gt;
#include &lt;string.h&gt;
#include &lt;stdlib.h&gt;

typedef struct {
	int sn_pos;
	char sn_id[12];
	int sn_update;
	char sn_file_size[12];
	int sn_active;
} sort_sn;

int sn_sort( const void *left, const void *right ) {
	const sort_sn *b = ( const sort_sn *)left;
	const sort_sn *a = ( const sort_sn *)right;

	if (b-&gt;sn_pos &lt; a-&gt;sn_pos) {
		return -1;
	} else if (a-&gt;sn_pos &lt; b-&gt;sn_pos) {
		return 1;
	} else {
		return (a-&gt;sn_id &lt; b-&gt;sn_id) - (b-&gt;sn_id &lt; a-&gt;sn_id);
	}
}

int main(int argc, char const *argv[]) {

	json_object *JSON_FILE = json_object_from_file(&quot;./Config.json&quot;);
	json_object *LIST = json_object_object_get(JSON_FILE, &quot;LIST&quot;);

	size_t LIST_Len = json_object_array_length(LIST);

	sort_sn meineDatenArray[LIST_Len];

	for (int a = 0; a &lt; LIST_Len; a++) {
		json_object *OBJ = json_object_array_get_idx(LIST, a);
		json_object *ID = json_object_object_get(OBJ, &quot;ID&quot;);
		json_object *POS = json_object_object_get(OBJ, &quot;POS&quot;);
		json_object *UPDATE = json_object_object_get(OBJ, &quot;UPDATE&quot;);
		json_object *FILE_SIZE = json_object_object_get(OBJ, &quot;FILE_SIZE&quot;);
		json_object *IS_ACTIVE = json_object_object_get(OBJ, &quot;IS_ACTIVE&quot;);

		meineDatenArray[a].sn_pos = json_object_get_int(POS);
		strcpy(meineDatenArray[a].sn_id, json_object_get_string(ID));
		meineDatenArray[a].sn_update = json_object_get_int(UPDATE);
		strcpy(meineDatenArray[a].sn_file_size, json_object_get_string(FILE_SIZE));
		meineDatenArray[a].sn_active = json_object_get_int(IS_ACTIVE);
	}

	qsort(meineDatenArray, LIST_Len, sizeof(sort_sn), sn_sort);

    for (size_t i = 0; i &lt; LIST_Len; i++) {
        printf( &quot;%d, %s, %s\n&quot;, meineDatenArray[i].sn_pos, meineDatenArray[i].sn_id, meineDatenArray[i].sn_title );
    }

	return 0;
}

Natürlich ist der Weg weit aus länger aber war mein Gedanke mal anders anzugehen.
Wie gesagt, Dank dir für die Hilfe 
]]></description><link>https://www.c-plusplus.net/forum/topic/355352/json-c-array-sortieren</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355352/json-c-array-sortieren</guid><dc:creator><![CDATA[s0pply]]></dc:creator><pubDate>Fri, 12 Sep 2025 12:33:32 GMT</pubDate></item><item><title><![CDATA[Trigraphs in g++ aktivieren?]]></title><description><![CDATA[Ich habe testweise ChatGPT-5 nach diesem Thread befragt. Hier sein Kommentar:
Trigraphs: Status, Schalter, Alternativen

Was sind Trigraphs – und warum sind sie weg?

Trigraphs sind Sequenzen wie ??&lt; (→ {) oder ??= (→ #). Sie wurden eingeführt, um auf exotischen Zeichensätzen fehlende Zeichen darzustellen.
Seit C++17 (und seit C23 auch im C-Standard) sind sie entfernt.
{  ??&lt;     }  ??&gt;     [  ??(     ]  ??)
#  ??=     \  ??/     ^  ??'     |  ??!     ~  ??-


GCC / g++

C-Modus: Mit -ansi (= -std=c90) sind Trigraphs an.
Moderne Standards (C99, C11, C17, C2x): Trigraphs aus.
C++17+: Trigraphs endgültig entfernt.
Beispiel (nur Preprocessing anzeigen, um die Ersetzung zu sehen):
gcc -E -std=c90 file.c


Clang
Verhält sich wie GCC: in alten Standards aktiv, ab C++17 entfernt.


MSVC
Hat noch einen Schalter: cl /Zc:trigraphs file.cpp


Alternativen
Digraphs (&lt;% %&gt; &lt;: :&gt; %: %:%:) – bleiben gültig.
Alternative Tokens (and, or, not …).
Am besten: UTF-8 Toolchain einsetzen.


Typische Stolperfallen
Trigraphs greifen vor der Tokenisierung – sogar in Strings und Kommentaren.
Beispiel: ??/ → \ konnte eine Zeilenfortsetzung erzeugen → zerstörte Strings/Kommentare.


Praxis-Empfehlung




Alten Lehrbuchcode (C90) wirklich so kompilieren:
gcc -std=c90 -Wall -Wextra file.c


Moderne Projekte:
gcc -std=c17 -Wall -Wextra file.c


oder für C++:
g++ -std=c++20 -Wall -Wextra file.cpp



Retro-Hinweis
Für 8-bit Retro (C64, Atari) ist cc65 die bessere Wahl – komplett ohne Trigraphs.

Kurz gesagt:
Trigraphs sind ein historischer Workaround. Heute am besten gar nicht mehr nutzen. Wenn unbedingt nötig: bei GCC im C90-Modus oder bei MSVC mit /Zc:trigraphs.
]]></description><link>https://www.c-plusplus.net/forum/topic/355348/trigraphs-in-g-aktivieren</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355348/trigraphs-in-g-aktivieren</guid><dc:creator><![CDATA[Erhard Henkes]]></dc:creator><pubDate>Mon, 01 Sep 2025 17:51:50 GMT</pubDate></item><item><title><![CDATA[Nach include zwingend Zeilenumbruch?]]></title><description><![CDATA[@Yadgar sagte in Nach include zwingend Zeilenumbruch?:

ḿain() ohne Rückgabetyp war zu Zeiten von C90 noch zulässig,

Ich habe damals (Anfang der 1990er) C gelernt, und nein es war nicht mehr üblich das so zu machen. Alter Code ließ sich natürlich weiterhin so übersetzen. Das Problem ist, dass das Buch einen veralteten Stil pflegt, und das hätte man eigentlich damals schon nicht mehr tun sollen.
Das ist ungefähr so sinnvoll wie Fortran Neulingen im Jahr 2025 COMMON Blöcke als guten Stil nahezulegen. Es gibt seit Fortran 90 sehr viel bessere Alternativen.
]]></description><link>https://www.c-plusplus.net/forum/topic/355349/nach-include-zwingend-zeilenumbruch</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355349/nach-include-zwingend-zeilenumbruch</guid><dc:creator><![CDATA[*john 0]]></dc:creator><pubDate>Sun, 31 Aug 2025 14:59:56 GMT</pubDate></item><item><title><![CDATA[Atomare (C99) &quot;struktur&quot;]]></title><description><![CDATA[@SoIntMan sagte in Atomare (C99) &quot;struktur&quot;:

aber ist windows nicht das LLP64 data model long == 32bit?

Stimmt.
Dann würde ich aber trotzdem eine Assertion (assert(sizeof(LONG) == sizeof(*ptr));)  hier hinzufügen. Einfach um sicher zu gehen.
]]></description><link>https://www.c-plusplus.net/forum/topic/355331/atomare-c99-struktur</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355331/atomare-c99-struktur</guid><dc:creator><![CDATA[Quiche Lorraine]]></dc:creator><pubDate>Wed, 09 Jul 2025 06:23:07 GMT</pubDate></item><item><title><![CDATA[Public API Methods with errorCode.]]></title><description><![CDATA[@SeppJ sagte in Public API Methods with errorCode.:

Unter diesen beiden: Variante 1. Du solltest auch die Möglichkeit durchdenken, dass nicht der Caller das errorCode-Struct eingibt, sondern dass der Fehlerverursacher das Objekt erzeugt. Und es ansonsten NULL setzt. Das macht die Benutzung sehr viel einfacher und es werden auch nur im Bedarfsfall Error-Structs erzeugt. Fehlerbehandlung ist dann auch sehr lesbar:
ErrorCode *error;
my_function(error);
if (error) ...

Hintereinanderschalten und Schachtlung von Funktionen und Durchreichen von Fehlern ist auch einfach. Siehe beispielsweise hier, wie das in bekannten und erfolgreichen Libraries gemacht wird:
https://docs.gtk.org/glib/error-reporting.html
(und viele andere auch, denn das Konzept ist solide)
Zwei Möglichkeiten will ich noch erwähnen:

Klassisch mit globalem Error-Flag, wie mit ERRNO &amp; Co. in der Standardbibliothek. Bin kein Fan, die Probleme sind offensichtlich. Aber es ist einfach und unsichtbar.
Wenn du immer überall objektorientiert bist (oder wenigstens dort, wo Fehler passieren können), also deine Ergebnisse immer per Pointerargument zurück in deine &quot;Objekte&quot; schreibst, dann bleibt der Rückgabewert für Fehlercodes frei. Siehe beispielsweise Linux-Syscalls, die fast alle einen int zurück geben, der den Erfolg oder nicht-Erfolg der Funktion beschreibt. Nur triviale Getter-Funktionen, bei denen nichts schief gehen kann, geben direkt einen Wert zurück. Das ist auch ein solides Konzept.

Was ich auch immer im fragen würde bei der Entscheidung ist, ob und wie leicht der Anwender die Fehlerprüfung vergessen kann, und was für Konsequenzen das hätte:

Bei einem expliziten error-Parameter kann man das gar nicht vergessen und es wäre schon sehr schlampig als Anwender, diesen nicht auszuwerten, wenn man ihn übergibt. Dafür muss man ihn aber auch immer angeben, ob man will oder nicht.
Bei einem Rückgabewert (und erst recht ganz schlimm einem globalen Flag) kann man die Auswertung auch vergessen. Klingt erst einmal schlimm, aber sind wir doch mal ehrlich: Wie oft habt ihr schon den Rückgabewert von printf ausgewertet? Wusstet ihr überhaupt, dass das einen Fehlerindikator hat, der ausgewertet werden kann? Nicht alles, was theoretisch schief gehen kann, braucht man praktisch zu prüfen.


Hallo, danke für deine Ausführungen.
In meinem Fall &quot;muss&quot; der Error-Struct instanc bzw die Referenz definitiv vorhanden sein, da die Lib ein statische objekt model verwendet (kein malloc darf verwendet werden) . Ein error null ptr wird mit einem eigenes assert callback (release) geprüft. (oder ich setze einfach kein errorCode, und implementiere das selbe verhalten mit oder ohne error instanz.
Wenn methoden keinen wird zurück geben, würde ich trotzdem gern per Konvention ein error ref mitgeben... so meine Idee der API 
Und ein Globales error like GetError WinApi oder so, wäre nichts für mich;)
@Quiche-Lorraine sagte in Public API Methods with errorCode.:

@SoIntMan
Ich nutze einen Ansatz ähnlich zu 1.)
typedef int tErrorCode;             ///&lt; 0 = OK, &lt; 0 = Fehlercode
#define ERR_CODE_FOO;


tErrorCode Foo()
{
}

bool Bar(tErrorCode* Err)
{
}

Ein Struct birgt meiner Meinung nach die Gefahr dass man weitere Elemente hinzufügt, welche sich nicht unbedingt mit der API Schnittstelle vertragen.

Ich hätte mir gern ein error struckt mit 2 integer :
typedef struct{ int modulID; int errorCode} eError;

aber klar muss mir mal die &quot;user&quot; perspektive anschauen,  ob das ganze dann auch &quot;schön&quot; anwendbar ist...
]]></description><link>https://www.c-plusplus.net/forum/topic/355321/public-api-methods-with-errorcode</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355321/public-api-methods-with-errorcode</guid><dc:creator><![CDATA[SoIntMan]]></dc:creator><pubDate>Sat, 14 Jun 2025 14:06:11 GMT</pubDate></item><item><title><![CDATA[Table mit Auswahl und Verschieben]]></title><description><![CDATA[Als Einstieg in die ncurses Programmierung empfiehlt sich das NCURSES-Programming HOWTO. Aufpassen sollte man bei diesem HOWTO, dass noch die klassischen 8Bit Zeichensatz Schnittstellen beschrieben werden. In den Man Pages findet man dann die Informationen für die Unicode Versionen, die haben alle ein w im Namen und meist ein vorgestellten Unterstrich also mvadd_wch statt mvaddch.
]]></description><link>https://www.c-plusplus.net/forum/topic/355316/table-mit-auswahl-und-verschieben</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355316/table-mit-auswahl-und-verschieben</guid><dc:creator><![CDATA[*john 0]]></dc:creator><pubDate>Wed, 04 Jun 2025 08:39:51 GMT</pubDate></item><item><title><![CDATA[Inline Function Definition&#x2F;Declaration splitten!?]]></title><description><![CDATA[@SoIntMan sagte in Inline Function Definition/Declaration splitten!?:

interessant, aber wenn ich die die funktion welche in Lib A liegt in Lib B linke wird sie da ja nich ge-inlined?

Ein derartige Optimierung findet ich C nicht statt. Da dazu der Compiler die Funktion noch als präcompilierte Version vorliegen haben müsste. Das ist bei einer Library schon nicht mehr der Fall. Das heißt, es fehlen die notwendigen Informationen um solche Optimierungen vornehmen zu können. Daher kann der Compiler nur sehen, dass eine Funktion foo extern ist und später der Linker diese Funktion ins Binary einbindet. Das kann er entweder statisch machen, dann schaut er in der Archive Library nach dem Code und bindet in statisch in das Executable ein, oder er macht das dynamisch in dem gegen eine dynamische Library bindet.
Für das Wegoptimieren des Funktionsaufrufs braucht der Compiler Informationen über die Funktion, diese kann es nur haben, wenn er den Header lesen kann oder diesen in Form eines Moduls als Präcompilat vorliegen hat. In C gibt es aber keine Module, so dass Du nur mit precompiled Headers die Übersetzung beschleunigen kannst. Die Sichtbarkeit lässt sich darüber nicht beeinflussen.
]]></description><link>https://www.c-plusplus.net/forum/topic/355317/inline-function-definition-declaration-splitten</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355317/inline-function-definition-declaration-splitten</guid><dc:creator><![CDATA[*john 0]]></dc:creator><pubDate>Wed, 04 Jun 2025 08:33:59 GMT</pubDate></item><item><title><![CDATA[Probleme beim zusammenfügen 2er Codes]]></title><description><![CDATA[Gut, daß es jetzt funktioniert.

Habe das Void Voice ins Setup und die Void commands in den void loop zusammengeführt.

Du meinst, du hast den Code der Funktionenblöcke in die Hauptfunktionen hineinkopiert?
Du solltest, wie du es auch bei den anderen Funktionen gemacht hast, einfach diese dort aufrufen: voice(); (bzw. ich fände den Namen setup_voice() passender)
Du müsstest dann aber entweder die gesamte Funktion voice vor setup definieren oder aber zusätzlich die Deklaration void voice(); hinzufügen, damit der Name der Funktion bekannt gemacht wird.
PS:
Noch zur Wortwahl bzgl. void: dies gibt nur den Rückgabetyp einer Funktion an (dort kann auch ein anderer Typ wie char oder int stehen). void bedeutet aus dem englischen 'leer', d.h. daß es keinen Rückgabewert gibt (in Delphi wird dies z.B. procedure genannt).
]]></description><link>https://www.c-plusplus.net/forum/topic/355237/probleme-beim-zusammenfügen-2er-codes</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355237/probleme-beim-zusammenfügen-2er-codes</guid><dc:creator><![CDATA[Th69]]></dc:creator><pubDate>Sun, 27 Apr 2025 11:47:00 GMT</pubDate></item><item><title><![CDATA[Frage Cross-Platfrom design?]]></title><description><![CDATA[@Quiche-Lorraine sagte in Frage Cross-Platfrom design?:

BTW: Das Beispiel ist nicht gut, da wir hier von einem primitiven Datentyp bzw. int32_t reden.

ja das habe ich auch erkannt , war bissel zu arg im over-engineering...:)
ich werde jetzt die Standard typen c11 also in dem int32_t verwenden;)
]]></description><link>https://www.c-plusplus.net/forum/topic/355201/frage-cross-platfrom-design</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355201/frage-cross-platfrom-design</guid><dc:creator><![CDATA[SoIntMan]]></dc:creator><pubDate>Fri, 14 Feb 2025 08:07:41 GMT</pubDate></item><item><title><![CDATA[C Verständisfrage objekt kopie]]></title><description><![CDATA[@wob sagte in C Verständisfrage objekt kopie:

@SeppJ sagte in C Verständisfrage objekt kopie:

aber die Sprache richtet sich halt an Profis, die genau wissen, was sie tun.

Hat man damals, als man diese Regeln so bestimmt hat, wirklich gedacht &quot;Lass mal ne Sprache für Profis machen&quot;

Damals hatten sich die wenigsten hobbymäßig ne PDP-11 o.ä. ins Kinderzimmer gestellt. Von daher waren einfach alle Profis. Und Ziel von C war die Entwicklung von Unix portabler zu machen. Vorher war assembler das Mittel der Wahl.
]]></description><link>https://www.c-plusplus.net/forum/topic/355196/c-verständisfrage-objekt-kopie</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355196/c-verständisfrage-objekt-kopie</guid><dc:creator><![CDATA[Tyrdal]]></dc:creator><pubDate>Wed, 05 Feb 2025 10:36:34 GMT</pubDate></item><item><title><![CDATA[Kompilierfehler, Ideen?]]></title><description><![CDATA[@john-0 sagte in Kompilierfehler, Ideen?:

@Quiche-Lorraine sagte in Kompilierfehler, Ideen?:

Wir reden hier aber von Embedded C und nicht von Standard C. Und Embedded C verhält sich gerne mal anders als der Standard.

Wir reden von C bei dem die gets Funktion seit ANSI C 1989 als veraltet markiert wurde, und seit C2011 aus der Sprache komplett entfernt wurde.
Erschreckend ist, dass Du hier so einen Sermon schreibst, und das nicht weißt.

@john-0 :Wir wissen das alle! Wir sind bloß klug genug zu verstehen, dass es völlig egal ist, wenn der Scheibenwischerwasserstand niedrig ist, während das Licht für Motorschaden leuchtet. Und wenn da dauernd der Praktikant um das Auto tanzt und schreit &quot;Meister! Meister! Der Scheibenwischerwasserstand ist niedrig! Da dran liegt es! Das müssen wir sofort beheben! Das ist wichtig! Die anderen Gesellen haben offensichtlich alle keine Ahnung, wenn sie dies nicht sehen!&quot;, dann nervt das einfach nur. Vor allem, wenn der Praktikant auch noch keinen Wink mit egal wie dickem Zaunpfahl verstehen möchte.
]]></description><link>https://www.c-plusplus.net/forum/topic/355166/kompilierfehler-ideen</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355166/kompilierfehler-ideen</guid><dc:creator><![CDATA[SeppJ]]></dc:creator><pubDate>Thu, 02 Jan 2025 11:43:47 GMT</pubDate></item><item><title><![CDATA[In the middle of qsort, is there a way to stop it?]]></title><description><![CDATA[Since this was posted to the C++ section of the forum, I suggest std::sort + exceptions   (the topic has been moved to C, so my answer is not really useful any more, but maybe still fun to play with)
#include &lt;algorithm&gt;
#include &lt;fmt/core.h&gt;
#include &lt;fmt/ranges.h&gt;
#include &lt;vector&gt;
#include &lt;stdexcept&gt;

using namespace std;

bool compare(int a, int b) {
    fmt::println(&quot;{} &lt;=&gt; {}?&quot;, a, b);
    if (a == b) throw runtime_error(&quot;Equal numbers compared&quot;);
    return a &lt; b;
}

int main() {
    vector&lt;int&gt; a {1,5,3,5,6,2};
    try {
        sort(a.begin(), a.end(), compare);
    } catch (const runtime_error &amp;e) {
        fmt::println(&quot;Stopped sorting: {}!&quot;, e.what());
    }
    fmt::print(&quot;A: {}!&quot;, a);
}

]]></description><link>https://www.c-plusplus.net/forum/topic/355164/in-the-middle-of-qsort-is-there-a-way-to-stop-it</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355164/in-the-middle-of-qsort-is-there-a-way-to-stop-it</guid><dc:creator><![CDATA[wob]]></dc:creator><pubDate>Mon, 16 Dec 2024 23:22:26 GMT</pubDate></item><item><title><![CDATA[partieller Code (include *.c file) schlechter Stil?]]></title><description><![CDATA[@Th69 sagte in partieller Code (include *.c file) schlechter Stil?:

Das ist doch genau das, was ich auch mit den Makros gemacht habe (nur hier als Funktionsmakros - warum eigentlich?).

absolut, da stimmt.
@Th69 sagte in partieller Code (include *.c file) schlechter Stil?:

ist, daß zwar definitions statisch ist, bei jedem Aufruf aber die einzelnen Zuweisungen jeweils ausgeführt werden (d.h. die Daten kopiert werden) -&gt; das kann doch nicht wirklich dein Ziel sein...

ja da hast du auch recht, aus der sichtweiße dann doch mit makros. die aufrufw finden nur selten statt, aber ich geb dir recht;)
]]></description><link>https://www.c-plusplus.net/forum/topic/355119/partieller-code-include-c-file-schlechter-stil</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355119/partieller-code-include-c-file-schlechter-stil</guid><dc:creator><![CDATA[SoIntMan]]></dc:creator><pubDate>Thu, 31 Oct 2024 04:05:46 GMT</pubDate></item><item><title><![CDATA[C func-ptr to C++ std::function]]></title><description><![CDATA[@Th69 sagte in C func-ptr to C++ std::function:

Das habe ich mir gedacht, daß jetzt diese Frage kommt.
Antwort: Mittels &quot;Compilermagie&quot;!
So viel ich weiß (bzw. mal gelesen habe), erzeugt der C#-Compiler eine eigene Datenstruktur mit einem Zeiger (IntPtr) auf eine aus der Memberfunktion erzeugten neuen Funktion, wo die Zugriffe auf die Membervariablen dann auf diese Datenstruktur umgebogen sind. Und vor dem Aufruf werden dann diese Variablen aus den Membervariablen kopiert und nach dem Aufruf wieder zurückkopiert (Marshalling).
Gefunden habe ich dazu nur noch Proposal: C# should provide better interop with unmanaged function pointers (von 2017), wo es darum ging, daß C# direkt C-Funktionzeiger unterstützen soll (ohne Marshalling), was auch jetzt seit C# 9 (C# - Function Pointers for High-Performance Scenarios ) möglich ist.
Das ist der Vorteil von Sprachen mit Reflection bzw. dynamischer Codererzeugung (wobei ich nicht genau weiß, ob dies direkt beim Compilieren oder aber einmalig zur Laufzeit erzeugt wird).
Dies ginge sicherlich auch mit C++, aber bisher unterscheidet C++ eben streng zwischen Funktionszeigern (R ()(...)) und Memberfunktionszeigern (R (C::)(...)).
Dafür bräuchte man wohl dann ein eigenes Schlüsselwort - und außerdem setzt C++ (wie C) auf hohe Performance. std::function&lt;...&gt; ist dabei ein Kompromiss um einen Datentyp zu haben, welcher beides unterstützt - aber eben keine Konvertierung ermöglicht.
Wenn du es bei C# mal genauer wissen willst, dann könntest du einen C# Compiler wie SharpLab benutzen und dir den generierten Code bzw. IL-Code anschauen.

erstmal &quot;Chapeau&quot;, was du so ausm stehgreif weißt;)
zum glück habe ich die c- codebase in der hand.. ich werde jetzt dem callback ein &quot;context/tag&quot; void* mit geben.

lib_register(this,callback)


dann geht das auch so;)
]]></description><link>https://www.c-plusplus.net/forum/topic/355117/c-func-ptr-to-c-std-function</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355117/c-func-ptr-to-c-std-function</guid><dc:creator><![CDATA[SoIntMan]]></dc:creator><pubDate>Mon, 28 Oct 2024 10:07:43 GMT</pubDate></item><item><title><![CDATA[statische komplexe objekte initialisieren Frage&#x2F;Problem]]></title><description><![CDATA[@Th69 sagte in statische komplexe objekte initialisieren Frage/Problem:

OK, der MSVC (mit &quot;/std:c11&quot;) kompiliert diesen Code nicht: Godbolt-Link
Auch umgekehrt nimmt er es nicht: Godbolt-Link
Er versteht anscheinend nur die direkte Initialisierung mit den geschweiften Klammern.
Edit:
Das einzige, was mir auf Anhieb einfällt, wäre mittels Makros: Godbold-Link

oh danke dir für deine Mühen.. ok ist aber kein KO kriterium ich überlege mir was;) MACRO is ganzgut
]]></description><link>https://www.c-plusplus.net/forum/topic/355082/statische-komplexe-objekte-initialisieren-frage-problem</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355082/statische-komplexe-objekte-initialisieren-frage-problem</guid><dc:creator><![CDATA[SoIntMan]]></dc:creator><pubDate>Fri, 20 Sep 2024 08:16:58 GMT</pubDate></item><item><title><![CDATA[Pointer auf globale statisch variablen]]></title><description><![CDATA[@Finnegan sagte in Pointer auf globale statisch variablen:

Du solltest allerdings darauf achten, dass du das const sauber mitführst. pList sollte entweder auch ein const char* sein, oder du solltest eine Kopie zurückgeben.

ok danke das werde ich tun.. 
]]></description><link>https://www.c-plusplus.net/forum/topic/355066/pointer-auf-globale-statisch-variablen</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355066/pointer-auf-globale-statisch-variablen</guid><dc:creator><![CDATA[SoIntMan]]></dc:creator><pubDate>Wed, 18 Sep 2024 09:57:46 GMT</pubDate></item><item><title><![CDATA[gstreamer und Windows]]></title><description><![CDATA[Hat von euch einer mal gstreamer mit Windows verwendet ?
Ich bin mit gstreamer am probieren. Mit Linux funktioniert alles wunderbar.
Ich habe mir mal extra ein abgespecktes Programm geschrieben, welches die lisb/DLLs nativ einbindet. Funktioniert unter Linux.
// === Linux
// gcc main.c -o main `pkg-config --cflags --libs gstreamer-1.0 gstreamer-audio-1.0`

// === Windows
// x86_64-w64-mingw32-gcc  main.c -o main `pkg-config --cflags --libs gstreamer-1.0 gstreamer-audio-1.0 ?????

// x86_64-w64-mingw32-gcc  main.c -o main -lgstreamer-1.0-0 -Ldll

#include &lt;stdio.h&gt;

extern void   gst_init(int *argc, char **argv[]);
extern void * gst_parse_launch(const char * pipeline_description, void ** error) ;
extern int    gst_element_set_state(void *element, int state);

int main (int argc, char *argv[]) {
  gst_init (&amp;argc, &amp;argv); 

  void * pipeline = gst_parse_launch(&quot;'filesrc location=/home/tux/Schreibtisch/sound/test.mp3 ! decodebin ! audioconvert ! audioresample ! autoaudiosink&quot;, NULL);
  gst_element_set_state(pipeline, 4);

  printf(&quot;&lt;CTRL+C&gt; = stop\n&quot;);
  while (1) {  }
}

Aber starte ich es mit wine oder in der VB mit win10, bekomme ich folgender Fehler:
$ wine main.exe 

(main.exe:0): GModule-[1;35mCRITICAL[0m **: [34m19:51:54.120[0m: Cannot get symbol 'gst_init_static_plugins' from the current process since GLib was built f
or Universal Windows Platform apps


Und dies passiert schon bei gst_init.
Ich habe folgende DLLs:
-rw-rw-rw- 1 tux tux   29184 Jul 27  2023 ffi-7.dll
-rw-rw-rw- 1 tux tux 1480704 Jul 27  2023 glib-2.0-0.dll
-rw-rw-rw- 1 tux tux   19968 Jul 27  2023 gmodule-2.0-0.dll
-rw-rw-rw- 1 tux tux  314368 Jul 27  2023 gobject-2.0-0.dll
-rw-rw-rw- 1 tux tux 1302016 Jul 27  2023 gstreamer-1.0-0.dll
-rw-rw-rw- 1 tux tux   11776 Jul 27  2023 intl-8.dll
-rw-rw-r-- 1 tux tux  618440 Jan 17  2018 msvcp140_app.dll
-rw-rw-r-- 1 tux tux   35320 Mär  7  2021 vcruntime140_1_app.dll
-rw-rw-r-- 1 tux tux   86784 Feb  8  2018 vcruntime140_app.dll


Einer eine Idee, wieso das ganze unter Windows nicht will ?
]]></description><link>https://www.c-plusplus.net/forum/topic/355076/gstreamer-und-windows</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355076/gstreamer-und-windows</guid><dc:creator><![CDATA[Mathuas]]></dc:creator><pubDate>Wed, 11 Sep 2024 17:55:36 GMT</pubDate></item><item><title><![CDATA[strncpy (Source &gt; Dest) Verhalten]]></title><description><![CDATA[@SoIntMan sagte in strncpy (Source &gt; Dest) Verhalten:

@john-0 sagte in strncpy (Source &gt; Dest) Verhalten:

So wird das letzte Byte nicht kopiert und anschließen mit NUL überschrieben.

Ne femto Sekunde schneller;)))

Ich glaube auch, dass die beste Optimierungsmethode wohl ist, den String gar nicht erst kopieren zu müssen. Da sehe ich oft viel Potential bei String-Operationen. Es ist doch eher selten, dass man Strings tatsächlich &quot;bearbeitet&quot;. Meistens werden sie einfach nur hin- und hergeschoben 
]]></description><link>https://www.c-plusplus.net/forum/topic/355074/strncpy-source-dest-verhalten</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355074/strncpy-source-dest-verhalten</guid><dc:creator><![CDATA[Finnegan]]></dc:creator><pubDate>Tue, 10 Sep 2024 07:47:37 GMT</pubDate></item><item><title><![CDATA[Wo liegt de Test Code !?]]></title><description><![CDATA[@SoIntMan Die VS Solution und Projektstruktur muss nicht der Ordnerstruktur entsprechen. Du kannst jedem Projekt in einer Solution sagen, woher es welche Source Dateien nehmen soll, und zu was das Projekt kompiliert werden soll.
Im Konfiguration Manager kann man auch einstellen, welche Projekte bei welchem Build mit welcher Konfiguration kompiliert werden sollen.
Die Ordnerstruktur ist bei uns gewachsen und sieht etwas vereinfacht so aus
root
  -&gt; code
    -&gt;src
       -&gt; part a
       -&gt; part b
       -&gt; part c
       -&gt; ...
       -&gt; test
    -&gt; bin
    -&gt; build
  -&gt; resources
  -&gt; tools
  -&gt; setup

Im Solutionexplorer in VS habe ich dann:
root
   -&gt; part a
   -&gt; part b
   -&gt; part c
   -&gt; ...
   -&gt; test

VS ist da sehr frei, wie man die Dinge konfiguriert. Aber angenehmer ist es natürlich das von CMake oder so erledigen zu lassen.
]]></description><link>https://www.c-plusplus.net/forum/topic/355041/wo-liegt-de-test-code</link><guid isPermaLink="true">https://www.c-plusplus.net/forum/topic/355041/wo-liegt-de-test-code</guid><dc:creator><![CDATA[Schlangenmensch]]></dc:creator><pubDate>Mon, 02 Sep 2024 12:50:07 GMT</pubDate></item></channel></rss>