C (alle ISO-Standards)

• S

  C-Datei im neuen Kommandofenster öffnen?
  • sebl11  

  15
  0
  Stimmen
  15
  Beiträge
  1358
  Aufrufe

  S

  Cybertec schrieb: Es heisst system("cls"); Danke es funktioniert
• ?

  Probleme mit dem Kompilieren
  • Gast  

  10
  0
  Stimmen
  10
  Beiträge
  773
  Aufrufe

  ?

  mich persönlich stören sie auch nicht Den Compiler im Zweifel eben schon. Und Fehler sind menschlich, also durchaus auch mal vertretbar. Dennoch kann sich das kurze Durchlesen des soeben verfassten Textes manchmal lohnen und ist auch eine Art höfliche Geste dem nächsten Leser gegenüber.
• T

  towers of hanoi programmieren
  • tom 123  

  5
  0
  Stimmen
  5
  Beiträge
  1146
  Aufrufe

  ?

  Soll das auch grafisch sein?
• B

  Kleinste element im Array finden
  • Bers  

  7
  0
  Stimmen
  7
  Beiträge
  4573
  Aufrufe

  

  fghfgh schrieb: Es gibt bereits eine Funktion namens min. Der Name der Variable ist daher unter Umständen ungünstig und könnte zu Fehlern führen. In C gibt es standardmäßig keine Funktion min.
• ?

  inline wird zu einer richtigen Funktion
  • Gast  

  8
  0
  Stimmen
  8
  Beiträge
  1019
  Aufrufe

  C

  SeppJ schrieb: Moderne Compiler sind eigentlich recht aggressive Inliner Jop, VS inlinet alles: int main() { 00081000 push ebp 00081001 mov ebp,esp 00081003 push ecx 00081004 push ebx 00081005 push esi //void *arg1 = (void*)0x80001000; //int arg2 = 12; //void *returnValue = someOperation(arg1, arg2); //try //{ k_clear_screen(); 00081006 mov eax,0B8000h 0008100B mov bl,7 0008100D lea ecx,[ecx] 00081010 mov byte ptr [eax],20h 00081013 mov byte ptr [eax+1],bl 00081016 add eax,2 00081019 cmp eax,0B8FA0h 0008101E jb main+10h (81010h) k_printf("Welcome to HenkesSoft OS.", 0); 00081020 xor edx,edx 00081022 mov ecx,offset string "Welcome to HenkesSoft OS." (87810h) 00081027 mov al,57h 00081029 xor esi,esi 0008102B jmp main+30h (81030h) 0008102D lea ecx,[ecx] 00081030 cmp al,2Fh 00081032 jne main+4Ch (8104Ch) 00081034 mov al,byte ptr [ecx+1] 00081037 inc ecx 00081038 cmp al,6Eh 0008103A jne main+4Ch (8104Ch) 0008103C mov al,byte ptr [ecx+1] 0008103F inc ecx 00081040 add esi,0A0h 00081046 mov edx,esi 00081048 test al,al 0008104A je main+62h (81062h) 0008104C mov byte ptr [edx+0B8000h],al 00081052 inc ecx 00081053 mov byte ptr [edx+0B8001h],bl 00081059 mov al,byte ptr [ecx] 0008105B add edx,2 0008105E test al,al 00081060 jne main+30h (81030h) k_printf("The C kernel has been loaded.", 2); 00081062 mov edx,140h 00081067 mov ecx,offset string "The C kernel has been loaded." (8782Ch) 0008106C mov al,54h 0008106E mov esi,edx 00081070 cmp al,2Fh 00081072 jne main+8Ch (8108Ch) 00081074 mov al,byte ptr [ecx+1] 00081077 inc ecx 00081078 cmp al,6Eh 0008107A jne main+8Ch (8108Ch) 0008107C mov al,byte ptr [ecx+1] 0008107F inc ecx 00081080 add esi,0A0h 00081086 mov edx,esi 00081088 test al,al 0008108A je main+0A2h (810A2h) 0008108C mov byte ptr [edx+0B8000h],al 00081092 inc ecx 00081093 mov byte ptr [edx+0B8001h],bl 00081099 mov al,byte ptr [ecx] 0008109B add edx,2 0008109E test al,al 000810A0 jne main+70h (81070h) update_cursor(3, 0); 000810A2 mov ax,0Fh 000810A6 mov dx,3D4h 000810AA out dx,ax 000810AC mov dword ptr [ebp-4],0F0h 000810B3 mov ax,word ptr [ebp-4] 000810B7 mov dx,3D5h 000810BB out dx,ax 000810BD mov ax,0Eh 000810C1 mov dx,3D4h 000810C5 out dx,ax 000810C7 mov dword ptr [ebp-4],0 000810CE mov ax,word ptr [ebp-4] 000810D2 mov dx,3D5h 000810D6 out dx,ax 000810D8 pop esi return 0; 000810D9 xor eax,eax 000810DB pop ebx // } //catch(...) //{ // return 1; //} } 000810DC mov esp,ebp 000810DE pop ebp 000810DF ret
• ?

  Richtig nativen Code erzeugen - kernel nach dem bootloader
  • Gast  

  4
  0
  Stimmen
  4
  Beiträge
  763
  Aufrufe

  ?

  Achso, noch eine kleine Anmerkung am Rande: Ich würde natürlch auch gerne inline Assembler nutzen aber die hinterlistigen Schweinebacken von MS haben es in den VS2010 mittlerweile unterbunden, 64bittigen inline Assembler einzufügen bzw. zu kompilieren:-( Bisschen blöd nur wenn man jeden Schwachsinn den ich sonst über inline deklarieren würde auslagere und dann aufrufe. Erzeugt dann schon sehr viel Zeug das man nicht brauch. Sprich Funktionsaufrufe für eine Zeile Assembler..
• ?

  Funktionslisten erstellen und ausführen.
  • Gast  

  11
  0
  Stimmen
  11
  Beiträge
  1169
  Aufrufe

  ?

  Danke.
• S

  Bestimmen des nächsten Nachbarn in C
  • sebl11  

  23
  0
  Stimmen
  23
  Beiträge
  3945
  Aufrufe

  ?

  Das ist doch gar nicht nötig. Du bestimmst den Abstand von deinem Punkt zum ersten Eintrag und merkst dir '1. Eintrag'. Dann bestimmst den Abstand von deinem Punkt zum nächsten Punkt. Ist dieser kleiner mkerkst du dir '2. Eintrag' sonst bleibt es beim 1. So gehst du die ganze Liste durch. Am Ende hast du den Punkt mit dem kleinsten Abstand.
• ?

  Frage zu Zeitbeschränkungen
  • Gast  

  2
  0
  Stimmen
  2
  Beiträge
  465
  Aufrufe

  ?

  Natürlich in die for-Schleife, denn sonst wird ja nur einmal vor der Schleife geprüft. Da aber als if((clock() - programmstart) >= maximumTime * CLOCKS_PER_SEC) break; Oder als Bedingung in die for-Schleife: for(i = 0; (i < 20000) && ((clock() - programmstart) < maximumTime * CLOCKS_PER_SEC)); i++) {
• P

  Speicherzugriffsfehler
  • pilleee  

  10
  0
  Stimmen
  10
  Beiträge
  1371
  Aufrufe

  S

  @Wutz Spielverderber
• J

  Datei als Variable speichern
  • JFaron  

  3
  0
  Stimmen
  3
  Beiträge
  625
  Aufrufe

  J

  SeppJ_logout schrieb: fscanf? Dankö
• ?

  Die ISO hat ein Weihnachtsgeschenk gemacht.
  • Gast  

  4
  0
  Stimmen
  4
  Beiträge
  1012
  Aufrufe

  ?

  Blue-Tiger schrieb: https://www.varnish-cache.org/docs/trunk/phk/thetoolsweworkwith.html Schön zu sehen wie gut er sich mit den "Tools mit denen wir arbeiten" tatsächlich auskennt, sein erster Punkt wurde exakt so schon in C99 gemacht. Zumal er noch nichtmal hinterfragt wieso man das so macht. Selten dämlicher Beitrag.
• D

  Lokale variablen - Pointer vs. Array
  • Doltsche  

  6
  0
  Stimmen
  6
  Beiträge
  992
  Aufrufe

  

  icarus2 schrieb: Es gibt einen subtilen Unterschied zwischen char a[] = "ABCDE"; und char *cp = "FGHIJ". Ich versuche das mal zu erklaren: Ich auch: char a[] = "ABCDE"; Hier wird ein fortlaufender Speicherplatz von strlen("ABCDE")+1 Bytes reserviert (innerhalb von {} Codeblöcken mit auto, außerhalb mit (implizit) static Speicherklasse) und das Literal "ABCDE" wird ausschließlich zur Initialisierung, d.h. Befüllen des o.g. Speicherbereiches benutzt, mit '\0' Terminierung. "ABCDE" ist hier kein eigenes Speicherobjekt, das anderweitig ansprechbar/benutzbar wäre. Es ist wenn man so will flüchtig. char cp = "FGHIJ"; Reserviert einen fortlaufenden Speicherbereich von sizeof(char) Bytes (innerhalb von {} Codeblöcken mit auto, außerhalb mit (implizit) static Speicherklasse) und initialisiert diesen mit der Adresse eines weiteren Speicherbereiches irgendwo anders, in dem strlen("FGHIJ")+1 Bytes reserviert und entsprechend befüllt wurden (wie im oberen Fall). "FGHIJ" ist hierbei weiterhin über cp verwendbar, wenn cp mal geändert würde, wäre aber auch hier "FGHIJ" nicht mehr nutzbar, aber weiterhin vorhanden (irgendwo im Prozessspeicher), im Gegensatz zu oben. DirkB schrieb: Das Array a darfst du auch beschreiben, während der Speicher auf den cp zeigt i.A. konstant ist. Genauer wäre hier zu sagen, dass bei *char cp = "FGHIJ"; das Stringliteral selber nicht konstant ist (const char *cp) sondern lediglich standardisiert ist, dass der schreibende Zugriff auf Elemente dieses Literalarrays zu undefiniertem Verhalten führt. Zu erwähnen wäre noch, dass im Gegensatz zu C bei C++ hier const char *cp spezifiziert ist (ein Stringliteral ist hier also tatsächlich konstant per Definition), also char *cp="FGHIJ"; durchaus möglich wäre, in C++ hingegen nicht mehr standardkonform wäre und const char *cp="FGHIJ"; heißen müsste. Nichts­des­to­trotz ist es auch in C in gut gewarteten Quelltexte üblich, ein const als Compilerhinweis zu spendieren, falls sich der Zeiger nicht mehr ändert und anderweitig wiederverwendet wird, also ein "spendiertes" const würde bei char *p=0; char a[]="ABCDE"; char *cp="FGHIJ"; ... cp=a; ... p=cp; natürlich scheitern.
• J

  Frage zur Rekursion
  • jan91  

  6
  0
  Stimmen
  6
  Beiträge
  936
  Aufrufe

  

  Die Debugsymbole werden dort nicht abgelegt, die sind fest am Ende der Exe eingebaut und ändern am Programmablauf gar nix. Da werden bestimmte magische Werte zwischen die Stackframes geschrieben (z.B. 0xDEADBEEF oder etwas anderes, irgendwo ist das dokumentiert) und wenn eine Funktion verlassen wird, wird geguckt, ob sich da irgendetwas verändert hat. Wenn da andere Werte stehen, hat jemand über Arraygrenzen geschrieben oder anderen Unfug gemacht. Wenn in deinem Programm plötzlich der Wert 0xDEADBEEF irgendwo auftaucht, wurde über irgendwelche Grezen gelesen.
• D

  Problem mit Binärrechner, Array und Compilerausgabe
  • DANrulz81  

  32
  0
  Stimmen
  32
  Beiträge
  6535
  Aufrufe

  ?

  Mach dir da mal keinen Kopf drum, mit der Zeit entwickelt man einen Blick für Rekursion. Wichtig ist vor allem, zu lernen, große Probleme in kleinere aufzuspalten, dann drängt sich so etwas ggf. von selbst auf. Zwar ist in diesem speziellen Fall die Ausgabe einer Zahl in Binärdarstellung nur mit Mühe als großes Problem zu begreifen, aber aufspalten lässt sich das prima: 0 und 1 kann man direkt verarbeiten, bei größeren Zahlen muss erst der vordere Teil (also x / 2) binär ausgegeben werden und dann das was übrig bleibt. Es sei allerdings dazu gesagt: Rekursion beinhaltet einen gewissen Overhead. Jeder Funktionsaufruf bedeutet Arbeit für den Prozessor, und die lokalen Variablen einer rekursiven Funktion liegen vielfach gleichzeitig im Speicher. In manchen Fällen ist dieser Mehraufwand vernachlässigbar, in anderen kann er kräftig Performance und Speicher kosten - bei großen Rekursionstiefen oder hohem Speicherverbrauch innerhalb rekursiver Funktionen kann einem schnell der Stack überlaufen. Auch wenn sich viele Sachverhalte elegant rekursiv darstellen lassen, ist mitunter ein weniger hübscher iterativer Ansatz zweckmäßiger. In unserem Fall dürfte Performance keine Rolle spielen, daher ist das so durchaus vertretbar, aber im Grunde ist es schon ein bisschen dekadent, für jede Ziffer einen eigenen stack frame aufzumachen.
• ?

  4Byte - ArraySort
  • Gast  

  12
  0
  Stimmen
  12
  Beiträge
  1407
  Aufrufe

  

  SanDi3go schrieb: Inhalt Array [ A | B | C | D | E | F | G | H |...] ==Sort==> [ D | C | B | A | H | G | F | E |...] Du kannst htonl (POSIX,winsock für Windows) für little endian Systeme verwenden: http://ideone.com/zWTyZ
• ?

  wchar_t zu string || Unicode in String
  • Gast  

  5
  0
  Stimmen
  5
  Beiträge
  1350
  Aufrufe

  

  swprintf ist nur C95, statt UCN zu verwenden bleibst du mit wchar_t euro=0x20ac; portabel, warum verwendest du nicht swprintf selbst für den Stringzusammenbau? Was soll das ominöse str_format? Um das Euro-Zeichen auch zur Anzeige zu bringen, muss der aktuelle Font dies natürlich auch unterstützen, ebenso handelst du dir nur unnötige Abhängigkeiten zwischen dem aktuellen Font deines Editors und dem der Laufzeitumgebung ein, wenn du solche Widechars direkt im String vorgibst, dann lieber o.g.
• K

  Eigene Funktion
  • kvora  

  3
  0
  Stimmen
  3
  Beiträge
  1416
  Aufrufe

  

  kvora schrieb: meine Frage bzgl. eigener Funktionen ist, wie ich da zwei Parameter (hier für Fläche/Umfang) zurückgeben kann, Die Ergebnisse der Berechnung (Umfang und Fläche) sind über die Parameterliste zurückzugeben. Du sollst da mit Zeigern arbeiten und darüber die Werte zurückgeben und wie ich das gleichzeitig in abhängigkeit von der anderen Funktion machen kann, die ja praktisch als Bedingung für die andere da ist? Indem du die andere Funktion benutzt? Zum Beispiel ganz am Anfang: if (pruefe(parameter)) { eigentliche rechnung } else { fehlerfall }
• T

  argumente als environmentvariablen
  • Theseus  

  3
  0
  Stimmen
  3
  Beiträge
  613
  Aufrufe

  S

  Mit C ist das nichts zu machen. Aber betriebsystemspezifisch gibt es die Möglichkeit Kommandozeilenargumente zu Umgebungsvariablen zu machen. Naja wo es ein getenv gibt, findet sich auch ein _putenv. :xmas2: Damit kann ein Programm seine Parameter als Umgebungsvariabeln im laufenden Prozess definieren. Diese Funktionen und viele mehr finden sich in der CRT von VC (stdlib.h). Mit der WINAPI gibt es folgendes GetEnvironmentStrings http://msdn.microsoft.com/en-us/library/windows/desktopms683187%28v=vs.85%29.aspx SetEnvironmentStrings oder GetEnvironmentVariable http://msdn.microsoft.com/en-us/library/windows/desktop/ms683188%28v=VS.85%29.aspx SetEnvironmentVariable Über CreateProcess kannst Du Deinen eigenen Envinroment-Block mitgeben, der unabhängig von den Umgebungsvariablen ist. Denke bei Linux/Unix gibts vergleichbares. Auch wenn das etliche (ich) nicht kennen. Gruss
• L

  Mehrere logische Bedingungen testen
  • lion1981  

  23
  0
  Stimmen
  23
  Beiträge
  2434
  Aufrufe

  

  lion1981 schrieb: Peinlich, ich weiß. Bitte nicht lachen... (schmunzeln ist allerdings erlaubt) Hallo, das muß Dir nicht peinlich sein, solche Fehler passieren mir auch noch trotz >30 Jahre Entwicklungserfahrung. Warum es aber so lange gebraucht hat, den Fehler zu finden, sollte Dir bewusst sein: Du hast auf Teufel komm raus versucht, Deiner Prüfroutine beizubringen, eine 1 zurückzuliefern. Du bist aber nicht auf die Idee gekommen, die Eingangsparameter der Funktion zu überprüfen. Zur Fehleranalyse gehört aber immer zuerst die Eingangsparameter zu verifizieren. Dann hättest Du nämlich festgestellt, daß die Prüfroutine gemäß ihrer Spezifikation korrekt funktioniert hat, woraus gefolgert werden kann, daß entweder die Spek falsch ist oder der Zulieferer einen Fehler hat. Das darf Dir dann aber wirklich peinlich sein, denn das lernt man im ersten Semester. mfg Martin