[A bis Z] C Programmiersprache lernen!

RichardJackson

Katılımcı Üye
13 Ocak 2018
700
1
Viyana
C Programmiersprache 1 - Informationen zur Kompilierungszeit​

C Programmiersprache

Hallo Freunde, in diesem Artikel werde ich über die Details und Feinheiten der Programmiersprache C sprechen. Es wird ein langfristiger Artikel sein. Ich werde versuchen, so viel wie möglich einzugeben und die Zeigerlogik so einfach wie möglich zu erklären.



Warum sollten wir C lernen?

Programmiersprachen bestehen aus einem Werkzeug, das auf dem Weg zur Lösung des Problems verwendet wird. Mit jeder Programmiersprache kann das X-Problem gelöst werden. Unabhängig davon, welche Sprache zur Lösung des X-Problems geeignet ist, kann dieses Problem diskutiert werden. Bestimmte Programmiersprachen sind entstanden, um bestimmte Probleme zu lösen. Wie Sie im Artikel sehen werden, ist der Grund für die Entstehung der C-Sprache, dass UNIX entwickelt werden soll. Mit anderen Worten, wir können sagen, dass jede Sprache bestimmte Verwendungszwecke hat. Die Programmiersprache C arbeitet sehr schnell, da sie der symbolischen Maschinensprache am nächsten kommt. Es ist die schnellste Sprache auf dem Markt. Wie Sie diesem Satz entnehmen können, sollten wir diese Sprache verwenden, wenn die Geschwindigkeit kritisch ist. Eingebettete Systeme, Systemprogramme, Betriebssysteme, autonome Fahrzeuge, Smart-Home-Systeme. Wir können sagen, dass C / C ++ ein Muss in der Welt dieser Anwendungsbereiche ist.

Welchen Vorteil wird C haben?


Wenn Sie C zuerst kennen, können Sie die Programmierlogik viel besser verstehen als in anderen Sprachen. Der C-Lernende muss die Algorithmen entwickeln, für die er denkt, da es nicht viele Funktionen gibt. Kurz gesagt, das Lernen von C bietet die Möglichkeit, Algorithmen zu entwickeln. In dieser C-Sprache, die in direktem Zusammenhang mit Ram steht, können wir mit Ram die Themen wie Computerarbeitsarchitektur viel besser verstehen. Da alles in C-Sprache dem Entwickler überlassen bleibt, wurde ein Konzept namens Dynamic Memory Management erstellt. Mit diesem Konzept können wir den Heap-Stack-Bereich genauer kennenlernen. Die meisten Sprachen auf dem Markt sind von der C-Sprache inspiriert. C wird nie alt, es werden immer C / C ++ - Sprachen benötigt.
Kurz zusammengefasst;


* Die Fähigkeit Probleme zu lösen
* Computerarbeitsarchitektur
* Compiler-Arbeitslogik
* Verstehen Sie diese Sprachen leichter, wenn Sie zu anderen Sprachen wechseln
* Fähigkeit, an eingebetteten Systemen zu arbeiten
* Betriebssysteme näher kennenlernen (Arbeitslogik)


Geschichte der C-Sprache

0Qy6IO.jpg


Die Programmiersprache C wurde 1970-1971 als Nebenprodukt bei der Entwicklung des UNIX-Betriebssystems im Labor von AT & T Bell entwickelt. AT & T arbeitete dann an einem Betriebssystemprojekt namens Multics. AT & T zog sich aus diesem Projekt zurück und machte sich daran, eigene Betriebssysteme zu schreiben. Dieses Betriebssystem wurde ein Wortspiel über Multics gemacht und UNIX genannt. Zu dieser Zeit wurden Betriebssysteme in symbolischer Maschinensprache geschrieben. Ken Thompson hat die Programmiersprache B entwickelt, um die Sache zu vereinfachen. In den folgenden Jahren entwickelte Dennis Ritchie dies zu C. Das UNIX-Betriebssystem wurde 1973 mit C am Anfang neu geschrieben. Es war das erste Mal, dass ein Betriebssystem mit einer fortgeschrittenen Programmiersprache geschrieben wurde. Kurz gesagt, dieses Ereignis ist in der Geschichte der Programmierung revolutionär. In den 1980er Jahren brachte IBM seine ersten PCs auf den Markt. 1978 wurde 'The C Programming Language' von Dennis Ritchie und Brian Kernigan geschrieben. Die Programmiersprache C war die am häufigsten in PCs verwendete Sprache.

CBzdH1.jpg


Klassifikation der Rogramm-Ingenue-Sprachen nach Stufen

zH3WIM.jpg


Das Kriterium des Niveaus in Programmiersprachen repräsentiert die Nähe der Programmiersprache zur menschlichen Wahrnehmung. Hochsprachen sind die Sprachen, die der menschlichen Wahrnehmung am nächsten kommen, und sie sind leicht zu lernen. Niedrigsprachige Sprachen hingegen sind die am weitesten entfernten Sprachen der menschlichen Wahrnehmung und schwer zu lernen. Die Sprache der niedrigsten Ebene ist die Maschinensprache. Dieses System wird auch als Binärsystem bezeichnet. Wir sprechen von Codes mit nur 1 und 0, und Sie können mehr oder weniger erraten, wie schwierig und mühsam das Schreiben ist. Über dieser Sprache befindet sich eine Assemblersprache. Obwohl die Assemblierung einfacher ist als die Maschinensprache, ist es immer noch schwierig, eine Sprache für Personen zu erkennen und zu codieren. Darüber hinaus gibt es eine C-Sprache. Die C-Sprache ist näher an der englischen Sprache, aber mit ihren einfachen mathematischen Operationsmarkierungen und einfachen Schlüsselwörtern ist sie eine viel verständlichere Sprache (im Vergleich zur Assemblersprache).

COMPILE (Kompilieren)

1COQST.jpg


Compile ist ein englisches Wort. Auf Deutsch bedeutet es kompilieren. C ist eine Sprache, die kompiliert werden muss. Das Betriebssystem kann den Code, der aus den von uns geschriebenen englischen Wörtern besteht, nicht verstehen. Es muss diesen Code kompilieren und in Codeteile konvertieren, die es verstehen wird. Wenn wir einen C-Code kompilieren, wird er zuerst mit Hilfe des Assemblers in Assembler-Code konvertiert und dann in Maschinencode konvertiert, den wir Binärcode nennen. Jetzt versteht das Betriebssystem, welchen Code wir geschrieben haben.

Der heute am häufigsten verwendete Compiler ist der Compiler namens GCC. Es besteht aus den Initialen der Wörter GNU C Compiler. Es gibt auch mehrere Compiler auf der Microsoft-Seite.


IDE-KONZEPT

Normalerweise sind Compiler Programme, die über die Befehlszeile ausgeführt werden. Der Code wird in der Editorumgebung geschrieben, dieser Code wird auf dem Terminal kompiliert. Die Wahrheit ist so. Heute ist ein Konzept namens IDE entstanden. Es besteht aus den Initialen der Wörter Integrated Development Environment. Der Grund für das Herauskommen von IDEs besteht darin, das Programm in den Editor zu schreiben und es dann auf dem Terminalbildschirm zu kompilieren. Wenn wir eine IDE auf unserem Computer installieren, wird ein Compiler damit installiert. IDE ist eigentlich kein Compiler. Es ist ein Programm, das es uns leichter macht, Code zu schreiben und zu kompilieren. Es gibt Schaltflächen wie Kompilieren und Ausführen. Wenn es sich nicht um einen Compiler handelt, können Sie sagen, was die Kompilierungsschaltfläche bewirkt. Wenn wir diese Taste drücken, wird die Kompilierung manuell am Terminal entfernt. Das Programm im Hintergrund erledigt dies für uns.

Vorprozess

Bevor unser C-Programm kompiliert wird, durchläuft es einen Prozess namens Vorbehandlung. Dieser Prozess interpretiert die Zeilen, die mit dem # (Pfund) -Zeichen oben im Programm beginnen. Nachdem diese Zeilen interpretiert und die erforderlichen Operationen ausgeführt wurden, wird die Kompilierungsoperation gestartet.

Kompilierungsverarbeitung

Der Kompilierungsprozess beginnt mit dem Tokenisierungsprozess. Was ist das für ein Prozess, lassen Sie uns ein wenig darüber sprechen. Bevor der Compiler den Code versteht, wird sein Inhalt in Token-Teile zerlegt. Dabei betrachtet der Compiler die Namen und Phrasen nicht, sondern trennt sie nur in ihre Token. Er kann die Bedeutung des Codes nicht verstehen, was er tut, logische Fehler im Code in diesem Stadium. Wir können uns Token als die kleinste Einheit vorstellen. Lassen Sie uns untersuchen, was die Token sind.

Schlagwörter

Schlüsselwörter sind Wörter, die durch das Design der Sprache vorgegeben sind, die von Anfang an mit einer besonderen Bedeutung geladen sind und nicht in anderer Bedeutung verwendet werden dürfen. Es gibt 32 Schlüsselwörter in C.

4eH93O.jpg


Bezeichner

2LbxTT.png


Dies sind die ursprünglichen Namen, die den Entitäten der C-Sprache gegeben wurden. Als Beispiel können wir geben:
* Namen für Variablen
* Namen für Funktionen
* Namen für Konstanten
* Namen für die Etiketten


Operatoren

Operatoren sind Token, die einen bestimmten Prozess übernehmen. Obwohl sich die Programmierung von Programmiersprache zu Programmiersprache ändert, ist ihre Gesamtstruktur die gleiche. Wir können Dinge wie mathematische Operationen, Logikverarbeitung, durch Operatoren tun.

BeQIWK.jpg


Konstante/Literal (Konstanten)

Ausdrücke, die direkt die numerische Größe oder Zeichenfolge im Code angeben. Es gibt 3 separate Systeme zum Schreiben numerischer Konstanten.

* Dezimal (Dezimal)
* Hexadezimal (Hexadezimal)
* Oktal (acht)


Dezimalzahlen werden so geschrieben, wie sie geschrieben sind.
Wenn Sie Hexadezimalzahlen schreiben, werden diese geschrieben, indem Sie am Anfang die Werte '0x' oder '0X' annehmen. Beim Schreiben von Oktalzahlen werden diese am Anfang mit dem Wert '0' geschrieben.
0 × 35 (10), 035 (16), 35 (8)
Die 3 oben gezeigten Werte repräsentieren unterschiedliche Zahlen.


String Literal (Zeichenkonstanten)

Fest geschrieben zwischen doppelten Anführungszeichen. Sie zeichnen sich durch ASCII-Codes aus.

eHSN5O.jpg


Der Wert der Variablen a,b und c im obigen Code ist ein konstanter Wert. Wenn wir etwas in Form von c = a sagen würden, wäre das Innere des c-Wertes variabel und nicht fixiert.

Delimeter/Punctuators

Alle Atome, die zum Trennen von Ausdrücken verwendet werden, die von den oben genannten Gruppen ausgeschlossen sind, werden separatoren genannt. Beispielsweise sind ';' und ''' separate Atome.

Compilerregeln

KJKOyP.png


In der Tokenisierungsphase (Atome) darf kein Tippfehler (Syntax) vorhanden sein. Es gibt keine Regel zwischen 2 Token, z. B. das Überspringen von Linien, das Verlassen von Leerzeichen, das Verlassen von Leerzeichen. Selbst wenn wir einen sehr legit Code schreiben, werden diese Codes in der Öffnung der Tokenisierung kombiniert. Für den Programmierer ist es wichtig, legit code für Legitability zu schreiben, auch wenn dies keine Regel ist.

Globaler NameSpace/Lokaler Namespace

Der C-Code, den wir schreiben, besteht aus 2 verschiedenen Abschnitten. Globaler Namensraum und lokaler Namensraum. Der Teil unserer Funktionen ist unser lokaler Namensraum. Der Teil, der sich außerhalb der Funktionen befindet, ist unser globaler Namensraum. Wir werden direkt auf die Funktionen dieser Bereiche zurückkommen.

8PB8NI.jpg


Deklaration /Erklärung

Jeder Satz, den wir in der Sprache C verwenden, muss eine der beiden Strukturen im Titel enthalten. Erklärung bedeutet Benachrichtigung. Es werden keine Maßnahmen ergriffen. Es erfolgt nur eine Benachrichtigung. Es kann sowohl in der globalen Namespace-Domäne als auch in der lokalen Namespace-Domäne verwendet werden. Es bedeutet den Satz, mit dem wir eine Variable oder Funktion definieren. Wenn wir nicht deklarieren, erkennt der Compiler nicht, was diese Variable oder Funktion ist.

Aussage bedeutet Redewendung. Der Compiler weiß, dass er eine Aktion ausführen sollte, wenn er die Anweisungen sieht. Beim Schreiben einer Schleife, beim Setzen einer Entscheidungsstruktur, beim Rechnen usw. Redewendungen werden verwendet. Redewendungen können nicht in den globalen Namespace geschrieben werden. Es muss in der Funktion des lokalen Namespace geschrieben werden.


02ffLG.jpg


Wenn Sie den Code im oberigen Beispiel kompilieren, wird ein Fehler ausgegeben. Wir haben beide Variablen in der globalen Arena definiert, gemäß unserer Regel, die wir nur in der globalen Arena deklarieren konnten. Es gibt kein Problem beim Definieren der ersten Variablen, aber die zweite Variable enthält eine Anweisung. Das Hinzufügen einer Konstanten und einer Variablen bedeutet einen Ausdruck. Wir könnten 5 + 3 sagen, weil 2 Werte auch konstante Werte enthalten, aber wir können dies nicht verwenden.

# Richtlinie einschließen

Dieser Befehl ist der Präprozessorbefehl. Dieser Befehl gibt an, dass er an die Stelle kopiert wird, an der der Befehl während der Kompilierung platziert wurde. Löschen Sie diese Zeile und ersetzen Sie stattdessen den Inhalt der Datei mit dem Namen stdio.h. Das Wort #include bedeutet einschließen. Um die grundlegendsten Funktionen in der C-Sprache nutzen zu können, müssen wir im Gegensatz zu herkömmlichen Sprachen grundlegende Bibliotheken einbeziehen.

Grundlegende Bibliotheken, die in C Sprache vorkommen können

<stdio.h> Es ist die grundlegendste c-Bibliothek. Wir müssen auf die Standardeingabe- / Ausgabefunktionen zugreifen. Verwendet stdin-, stdout- und stderr-Dateien.

<stdlib.h> Es ist eine der grundlegenden c-Bibliotheken. Wir müssen diese Bibliotheken einschließen, um auf grundlegende Funktionen zugreifen zu können. Lassen Sie uns die Funktionen auflisten, die mit dieser Bibliothek geliefert werden.

Kod:
abort();
abs();
atexit();
atof();
atoi();
atol();
bsearch();
calloc();
div();
exit();
free();
getenv();
labs();
ldiv();
malloc();
mblen();
mbstowcs();
mbtowc();
qsort();
rand();
realloc();
srand();
strtod();
strtol();
strtoul();
system();
wcstombs();
wctomb();

<math.h> Wie der Name schon sagt, handelt es sich um eine Bibliothek mit Funktionen, mit denen wir mathematische Operationen ausführen können. Lassen Sie uns die Funktionen auflisten, die mit dieser Bibliothek geliefert werden.

Kod:
acts();
asin();
atan();
atan2();
ceil();
cos();
cosh();
exp();
fabs();
floor();
fmod();
frexp();
ldexp();
log();
log10();
modef();
pow();
sin();
sinh();
sqrt();
tan();
tanh();

<string.h> Dies sind Funktionen, mit denen wir bestimmte Operationen an Zeichenketten ausführen können. Diese Bibliothek enthält viele allgemeine Funktionen. Lassen Sie uns auch diese Funktionen untersuchen.

Kod:
memccpy();
memchr();
memcmp();
memcpy();
memcpy_s();
memmove();
memmove_S();
memset();
memset_s();
strcat();
strcat_s();
strchr();
strcmp();
strcoll();
strcpy();
strcpy_s();
strcspn();
strdup();
strerror();
strerror_s();
strerrorlen_s();
strlen();
strlen_s();
strncat();
strncat_s();
strncmp();
strncpy_s();
strndup();
strpbrk();
strrchr();
strspn();
strstr();
strtok();
strtok_s();
strxfrm();

# Richtlinie definieren


Definieren ist eine Präprozessorreihenfolge, die für unsere Daten verwendet wird, die wir definitiv nicht im Programm ändern wollen. Da es vom Präprozessor verarbeitet wird, wird es als Konstante / Literal und nicht als Variable im Programm ausgewertet. Im Allgemeinen erfolgt die Zuweisung von Namen zur Definition von Werten in Großbuchstaben, die nicht dem Wert und dem Namen entsprechen. Es bleibt nur ein Leerzeichen übrig.

Beispiel Verwendung;

Kod:
#define A 15
#define PI 3.14

Hinweis: Bei der Definition einer Konstanten mit Define wird häufig Großschreibung verwendet. Programmierer müssen darauf achten.


Variablen in C-Sprache

Variablen sind unsere Daten, die im Arbeitsspeicher (RAM) des Computers gespeichert sind und die wir jederzeit ändern können.


Warum brauchen wir Datenspeicherung?

- Möglicherweise möchten wir an bestimmten Stellen des Programms Daten vom Benutzer empfangen, um den Programmfluss von Benutzer zu Benutzer zu ändern.

In bestimmten Fällen möchten wir möglicherweise bestimmte Transaktionen ausführen und diese Transaktionen in einem anderen Teil des Programms verwenden. Dafür benötigen wir eine temporäre Speichereinheit.

Die Daten (Variablen), die wir auf dem RAM speichern, müssen einen bestimmten Datentyp haben. Wir müssen angeben, um welchen Datentyp es sich in der Zeile handelt, in der wir die Variable definieren. Kurz gesagt, wir verwenden eine solche Verwendung, um eine Variable zu definieren.

Kod:
Datentyp Variablenname (Bezeichner) = Variablenwert;

Wir bestimmen den Datentyp. Wir geben der Variablen einen Namen und dieser Name sollte hervorrufen, worum es in der Variablen geht, und sich dann daran erinnern, wenn Sie einen anderen Teil des Programms aufrufen. Während wir die Variable benennen, benennen wir sie unter bestimmten Regeln. Wir werden später zu diesen Regeln kommen. Und dann verwenden wir = (Zuweisungsoperator). Verwechseln Sie es nicht mit dem Gleichheitszeichen in Mathe. Das Ziel des Vorzeichens ist es, den Wert rechts gleich der Variablen links zu nehmen. Nach dem Zuweisungsoperator geben wir Daten entsprechend dem von uns bestimmten Variablentyp an.

Was ist, wenn wir die Daten vom Benutzer erhalten möchten?

Kod:
int x;
scanf("%d",&x);

Wenn wir die Daten vom Benutzer erhalten möchten, reicht es aus, nur den Datentyp und den Namen anzugeben. Wir machen Platz für die Variable im Speicher. Es hat noch keinen Wert im Speicher, aber es hat eine Adresse. Ordnen Sie der Programmvariablen x kurz einen Platz zu, den ich später ausfüllen werde. Wir erhalten Daten vom Benutzer mit der scanf-Funktion, mit der wir Eingaben vom Benutzer erhalten können, und speichern diese Daten unter der Adresse x.

Regeln für Variablennamen

-Der Name, den wir den Variablen geben, kann nicht mit der Nummer beginnen. Aber die Nummer kann in oder am Ende übergeben werden.

-Der Name, den wir Variablen geben, darf keine Sonderzeichen enthalten. Wir haben eine Ausnahme für diese Regel, _ kann verwendet werden.

-Der Name, den wir Variablen geben, darf nicht länger als 32 Zeichen sein.

-Der Name, den wir den Variablen geben, kann nicht die speziellen Wörter verwenden, die das Programm verwendet. (wie int, short, for, if, **** ...)

Variablen in der Sprache -c unterscheiden zwischen Groß- und Kleinschreibung, dh Groß- und Kleinschreibung.

Kod:
int hallo;
int hAlLo;

Die beiden oben definierten Variablen sind unabhängig voneinander. Wenn wir eine Variable mit einer Variablen definieren, die genau denselben Namen hat, wird eine Fehlermeldung angezeigt.

Grundlegende Datentypen in C-Sprache

Was ist der Datentyp? Lassen Sie mich zuerst darüber sprechen. Das Konzept, das wir Datentyp nennen, beschreibt den Typ der Variablen, die wir erstellen. Tatsächlich ist der Datentyp das Konzept, das für den Computer erstellt wurde, um zu verstehen, wie viele Bytes auf dem RAM gespeichert sind und wie diese Variable zu interpretieren ist. Jede Variable, die wir in Programmiersprachen speichern möchten, wird auf einem RAM an einer bestimmten Adresse gespeichert. Der Hauptgrund für die Aufteilung der Daten in Typen besteht darin, keinen unnötigen Speicherplatz auf dem RAM zu verschwenden. Wenn wir eine kleine Zahl verwenden, bestimmen wir den Datentyp entsprechend und verschwenden keine unnötigen Bytes. Wenn wir eine vorzeichenlose Ganzzahl verwenden, bestimmen wir sie entsprechend und verursachen keine Komplexität. Kurz gesagt, der Datentyp sagt uns, was die Daten sind. Alle Variablen im Speicher (auch wenn es sich um Zeichen handelt) konvertieren sie nach dem Kompilieren unseres Codes in Nullen und Einsen.

Char Datentyp

Der Char-Datentyp ist nur für 1 Zeichen. Es enthält ein Byte im Speicher und wird bei der Definition zwischen die Markierungen geschrieben. Da der für char im Speicher reservierte Teil ein Byte ist, können wir mit char nicht mehr als 255 Daten speichern. Wir hatten Zeichen, ich glaube, wir hören, was Sie mit diesem Datentyp sagen. Wie vergleichen wir die Zahl 255 mit dem Zeichen? Lesen wir den Satz, den ich oben geschrieben habe, noch einmal durch:

Alle Variablen im Speicher (gerade Zeichen) konvertieren sie nach dem Kompilieren unseres Codes in Nullen und Einsen.

Nehmen wir an, wir behalten den Buchstaben a in der Zeichenvariablen. Wie verwandeln wir den Buchstaben a in eine Zahl? Programmierer stellten sich diese Frage rechtzeitig und setzten einen Standard, da sie eine gemeinsame Lösung benötigten. Von der ganzen Welt akzeptierte Standards. Und sie nannten es den amerikanischen Standardcode für Informationsaustausch (ASCII).


00JRVx.jpg


Wie wir oben gesehen haben, gibt es für jeden Eingabewert auf der Tastatur einen numerischen Wert.

Definieren wir die Zeichenvariable und sehen ihre Entsprechung gemäß dem ASCII-Code.

Kod:
char a = 'a';
printf ("% d", a); // using integer, der ganzzahlige Wert
printf ("% c", a); // Verwenden des Platzhalters c den Zeichenfolgenwert

Wie Sie oben sehen können, haben wir sowohl den Zeichenwert als auch den Ganzzahlwert der Variablen a gedruckt.

Integer-Datentyp

Der Datentyp Integer ist unser Datentyp, in dem Ganzzahlen gespeichert werden. Obwohl der Speicherplatz von Computer zu Computer unterschiedlich ist, beträgt er im Allgemeinen 4 Byte. Der Wert von 4 Bytes kann 32 Bit annehmen, dh maximal 2 ^ 32-1. Mit dem Operator sizeof () können Sie herausfinden, wie viel Speicher der ganzzahlige Datentyp auf Ihrem Computer benötigt.

Definieren wir Variablen mithilfe des Integer-Datentyps.

Kod:
int x = 5;
printf("%i",x);
printf("%d",x);

Wir können 2 verschiedene Platzhalter für ganzzahlige Variablen verwenden. % d und% i. Im Allgemeinen ist die Verwendung von% d häufiger.

Float- und Double-Datentyp

Float- und Double Floating-Dezimalzahlen werden für Komma-Zahlen verwendet, wenn wir etwas türkischer sind. In der Programmiersprache trennen wir den Dezimal- und den Ganzzahlwert jedoch durch einen Punkt und nicht durch ein Komma. Da beide Dezimalwerte darstellen. Die Antwort ist einfach, wenn wir zu der Antwort kommen, warum wir zwei verschiedene Datentypen verwenden. Der Bereich, den sie speichern. Der Float-Datentyp weist bis zu 4 Byte zu, der doppelte Datentyp reserviert bis zu 8 Byte. Es entspricht 4 Bytes 32-Bit-Speicherplatz und kann tatsächlich so viele Daten wie Ganzzahlen speichern. Double ist genau doppelt. Die Berechnung von Gleitkommazahlen auf dem Computer liefert keine eindeutigen Ergebnisse. Je höher das Byte, desto näher kommt das Ergebnis der Genauigkeit. Wir können jedoch nicht sagen, dass dies absolut korrekt ist. Daher wird Programmierern empfohlen, den doppelten Datentyp zu verwenden.

Kod:
float x = 5.4;
float y = 5.0;
double z = 4.9;
double t = 4;

Alle oben genannten Verwendungen sind korrekt. Bei der letzten Verwendung wurde 4 direkt der Variablen t zugeordnet. Den ganzzahligen Wert speichert das Programm als Float im Speicher. Also 4.0. Wir verwenden% f Platzhalter beim Drucken für Float- und Double-Datentypen. Beim Lesen des Wertes (scanf) verwenden wir% lf für float% f double.


Eingabe- / Ausgabefunktionen in C-Sprache
Wenn wir eine Eingabe-Ausgabe-Funktion in unserem Code verwenden oder schreiben, liest oder druckt die Funktion keine Daten direkt von unserer Tastatur. Wir sagten, dass die C-Sprache zum ersten Mal mit UNIX auftauchte. Wenn Sie zuvor UNIX-Systeme untersucht haben, müssen Sie den folgenden Satz gehört haben.

Auf UNIX-Systemen ist alles eine Datei (einschließlich Hardware).

Kurz gesagt, in C schreiben wir in die Datei und lesen sie aus der Datei. Während wir Daten vom Benutzer empfangen, lesen wir aus einer Datei namens stdin, und wenn wir etwas auf dem Bildschirm drucken möchten, schreiben wir es in die stdout-Datei. Die Fehlermeldung wird auch aus der stderr-Datei gedruckt.

Ausgabefunktionen

Ich werde über die 2 grundlegendsten Ausgabefunktionen sprechen, printf () und putchar ().

Es werden 2 Argumente in die printf-Funktion aufgenommen. Im ersten Argument schreiben wir die Daten, die wir eingeben, in zwei Anführungszeichen oder den Platzhalter, den wir verwenden möchten. Wir schreiben auch einen Ausdruck anstelle des zweiten Arguments, vorausgesetzt, wir trennen zwei Argumente durch Kommas. wie a + b, c + 3, 3 + 2 ...

Die Putchar-Funktion dient, wie der Name schon sagt, dazu, ein einzelnes Zeichen zu drucken. Wir können Variablen direkt als Argumente oder das Zeichen als einfache Anführungszeichen ('') angeben.


Eingabefunktionen

scanf, getch, getche, getchar, bekommt .....

Viele Eingabefunktionen werden verwendet. Alle diese haben geringfügige Unterschiede. Reden wir über sie.

Die Scanf-Funktion ist die Eingabefunktion, die wir am häufigsten verwenden. Es sind 2 Argumente erforderlich. Wir können unseren Platzhalter in doppelten Anführungszeichen für das Argument auf der linken Seite definieren. Wir geben dem Argument rechts die Adresse der Variablen, die wir zuweisen möchten (& Variablenname). Diese Funktion liest das Teil, bis wir den leeren Wert angeben. Den Rest nimmt es nicht (wenn es 2 Variablen liest, wird es nach dem Leerzeichen einer anderen Variablen zugewiesen).

Die Gets-Funktion wurde später aus den C-Standards entfernt, ist aber immer noch eine Funktion, die wir verwenden können. Diese Funktion liest das Teil, bis die Eingabe (' n') eingegeben wird. So können wir unseren Satz beenden, wo immer wir wollen.

Die Getchar-Funktion ist eine Funktion, die sehr sorgfältig verwendet werden sollte. Wenn wir nach dem Grund fragen, liest diese Funktion Zeichen für Zeichen und wartet, bis die Eingabetaste gedrückt wird. Wir haben den Buchstaben K gedrückt und die Eingabetaste gedrückt. Er schreibt sowohl das Zeichen k als auch ' n' in die Standarddatei. Mit anderen Worten, wenn wir unsere Variable zweimal mit Putchar lesen, unterdrückt der erste den Buchstaben K und der zweite das Zeichen ' n'. Die Lösung, die wir verwenden müssen, ist die Funktion fflush (). Es wird verwendet, um den Dateifluss zu bereinigen. Wir werden den Dateistream löschen. Was ist mit dem Dateistream?

Ist die Antwort nicht klar? stdin ist eine Datei, die das Zeichen von getchar in diese Datei schreibt. Wir müssen den Fluss dieses Ortes räumen. fflush (stdin); Wir müssen den Fluss der stdin-Datei löschen.

Die Getch-Funktion ist in der Standardbibliothek <conio.h> nicht enthalten. Diese Funktion fungiert bei der Eingabe des Zeichens, sobald wir darauf warten, dass wir die Eingabetaste drücken. Aus diesem Grund wäre es logischer, diese Funktion beim Kauf von Zeichen zu verwenden.



Schleifen und Entscheidungsstrukturen

Lassen Sie uns über die Zyklen und Entscheidungsstrukturen sprechen, die die Grundbausteine ​​der Programmsprachen sind. Es gibt 3 verschiedene Schleifenstrukturen in der C-Sprache. Alle von ihnen können ineinander umgewandelt werden, es gibt keinen Unterschied zwischen ihnen. Lassen Sie uns über diese Zyklen sprechen;
for loop, while loop und do while loop


Für den Zyklus

Die Innenseite der for-Schleifen besteht aus 3 Teilen. Der erste Teil ist der erste Zuordnungsteil. In den alten C-Standards mussten wir den ersten Teil zur Variablenerstellung über der for-Schleife erstellen, in den neuen C-Standards wurde dies aufgehoben. Der zweite Teil ist der Bedingungsteil. Solange die Bedingung, die wir hier eingeben, wahr ist, funktioniert unser Zyklus. In der Schleife befindet sich ein 2-Punkt-Komma, und dieses 2-Punkt-Komma unterteilt die Schleife in 3 Teile. Der dritte Teil des Zyklus ist der Aktualisierungsteil. Wir müssen ein Update durchführen, um aus der Schleife herauszukommen, oder wir gehen in eine Endlosschleife.

Kod:
for (Beschreibungsteil; Steuerteil; Aktualisierungsteil);

While-Schleife

While döngüsünün içi bir kısımdan oluşur. Yapı olarak for döngüsünden farklı görünse de tamamen aynıdır. Her for döngüsü while döngüsü ile yapılabilir, her while döngüsü for döngüsü ile yapılabilir. While döngüsü tek kısımdan oluşuyor demiştik, bu kısım ise döngünün karar yapısı, true ise döngü çalışır. False ile döngü çalışmaz. C de true false olayından bahsetmiştik. 0 False değere sahiptir, onun dışındaki bütün değerler true değere sahiptir. Negatif sayılar da dahil olmak üzere.

Kod:
int j = 0; // Definitionsteil
while (j <10) // Steuerteil
{
j ++; // Abschnitt aktualisieren
}}

Do-While-Schleife

Die Do while-Schleife ist fast dieselbe wie die while-Schleife. Der einzige Unterschied besteht darin, dass die Operationen im Bereichsbereich zuerst ausgeführt werden und dann die Steuerung übergeben wird. Selbst wenn wir While 0 schreiben, werden diese Operationen mindestens einmal ausgeführt.

Kod:
do{

j++;

}while(j<10);

Wenn-sonst-Entscheidungsstruktur

If-Else-Entscheidungsstrukturen sind Strukturen, mit denen wir bestimmte Operationen unter bestimmten Bedingungen ausführen können. Der allgemeine Programmablauf wird durch die if-else-Struktur bestimmt. Eine oder mehrere Bedingungen können in If gestellt werden. Was es vom Zyklus unterscheidet, ist, dass die Transaktionen einmal ausgeführt werden.

Kod:
int x = 5;
if (x == 5)
{
printf ("wenn Bedingung funktioniert");
}}

Nach der if-Struktur wartet der Compiler auf die else-if- und else-Struktur. Ansonsten ist er nicht interessiert. Wenn If wahr ist, wird die Genauigkeit von else-if- oder else-Strukturen nicht überprüft.


Falsche Verwendung

Kod:
int x = 5;
if (x <10)
{
printf ("falls gearbeitet);
}}
wenn (x> 10)
{
printf ("Sekunde wenn gearbeitet");
}}

Ich habe oben einen Missbrauch gezeigt, warum Sie falsch sagen werden. Es ist nicht möglich, dass x gleichzeitig kleiner als 10 und x größer als 10 ist. Es ist entweder klein oder groß. Das Programm wird durch zweimaliges Aufrufen der if-Struktur verlangsamt. Die korrekte Verwendung sollte if-else oder if-else if sein. Denn wenn diese Strukturen wahr sind, werden andere abhängige Blöcke übersprungen.

Korrekte Nutzung

Kod:
int x = 5;
if (x <10)
{
printf ("falls gearbeitet);
}}
sonst wenn (x> 10)
{
printf ("sonst wenn gearbeitet");
}}


Switch-Case-Entscheidungsstruktur


Diese Entscheidungsstruktur ist eine Struktur, die verwendet werden sollte, wenn es viele Möglichkeiten gibt. Jede Switch-Case-Struktur kann mit if else if-Struktur geschrieben werden, jede if else if-Struktur kann mit switch case geschrieben werden. Aber in Fällen, in denen es viele Möglichkeiten gibt, ist die Verwendung von if else if sehr problematisch.

Kod:
Schalter (variabel)
{
Fall 1:
xxxxx;
brechen;
Fall 2:
JJJJJ;
brechen;
Fall 3:
zzzzzz;
brechen;
Standard:
Wert nicht gefunden;
}}

Es nimmt eine Variable in den Schalter auf, nehmen wir an, wir geben die Variable x. Wir betrachten den Wert in der Variablen X, lassen Sie diesen Wert 5 sein. schaut auf Fall 1 schaut auf 2, zuletzt schaut auf 3. Wenn keine gefunden wurde, wird standardmäßig die Standardeinstellung verwendet.

Was ist ein Zeiger?

Pointer ist ein englisches Wort. Deutsche Bedeutung Zeiger ist bezeichnend. Wie wir aus der Bedeutung des Wortes verstehen können, speichert das Konzept, das wir Zeiger nennen, die Adressinformationen einer Variablen. Es zeigt diese Variable. Kurz gesagt, der Zeiger ist die Adressinformation, in der eine Variable auf dem RAM gespeichert ist.

Wenn wir eine Variable in einer beliebigen Programmiersprache erstellen, wird die von uns erstellte Variable in einer zufälligen Speichereinheit auf dem RAM abgelegt. Die Adressierung auf dem RAM erfolgt gemäß der Hexadezimalzahl 16.

Kod:
int x = 5; // Wir erstellen eine Variable namens x und setzen 5 ein

Wir wissen, dass diese Variable x an einer zufälligen Stelle im Speicher gespeichert ist. Wir haben gesagt, dass diese Adresse auch im Hexadezimalformat angezeigt wird. Um diese Adresse zu lernen, müssen wir einen Zeiger definieren. Wir verwenden die * -Anweisung, um einen Zeiger zu definieren.

Kod:
int * p = & x; // Zeigervariable, die die Adresse der Variablen x enthält

Wir haben das & -Zeichen in dem Code verwendet, den wir oben gesehen haben. Der Name dieses Zeichens ist das kaufmännische Und-Zeichen. Es bedeutet, dieses Zeichen zweimal nebeneinander zu verwenden. Wenn wir es alleine verwenden, können wir es kurz als Ort von… zusammenfassen. Das kaufmännische Und-Zeichen gibt den Speicherort der Variablen an, dh die Adresse der Variablen.

Wenn wir eine Zeigertypvariable auf dem Bildschirm drucken möchten, müssen wir einen Platzhalter verwenden. Der Platzhalter, den wir für Zeiger verwenden, ist das% p-Zeichen.

Kod:
int x = 5;

int *p = &x;

printf("%p",p);

Dieser Code gibt uns die Adresse der Variablen x aus. Wenn wir den Code immer wieder ausführen, werden wir unterschiedliche Ergebnisse sehen. Wie im Einführungsteil des Artikels erwähnt, werden die Variablen zufällig auf dem RAM platziert.

Ist es möglich, den Wert in der Adressvariablen zu sehen, den der Zeiger weiterhin verwendet? Unsere Antwort lautet ja. Der von uns verwendete p-Zeiger zeigt die Position der x-Variablen. Die von uns verwendete x-Variable ist eine Ganzzahl. Welches Ergebnis erhalte ich, wenn ich den% d-Wert schreibe, bei dem es sich um den Platzierer von Ganzzahlwerten im Befehl printf handelt? Wir erwarten, dass es den Wert 5 druckt, oder?

Kod:
int *p = &x;

printf("%d",p);

Dieser Code gibt einen Fehler an uns zurück. Wenn wir zur Fehlerursache kommen, möchten wir den ganzzahligen Wert mit der Funktion printf unterdrücken. Deshalb haben wir den Ausdruck% d verwendet. Der Teil nach dem Komma muss ebenfalls ein ganzzahliger Wert sein. Aber wir schreiben p nach dem Komma. p Ganzzahl ist kein Wert. p ist eigentlich ein neuer Variablentyp. Denken Sie wie Integer, Float, Double, Char, Long, Pointer. Ganzzahl hat keinen Wert, sie hat einen Adresswert. Hier steht unsere Aussage * für unsere Hilfe. Dieser Ausdruck bedeutet den Wert innerhalb der Adresse, auf die der Zeiger zeigt. Was wir die Adresse nennen, auf die der Zeiger zeigt, ist tatsächlich die Adresse der Variablen x. Wir meinen also innerhalb der Adresse der Variablen x. Also der x-Wert, 5….



Der richtige Code lautet:
Kod:
int x = 5;

int *p = &x;

printf("%d", *p);

Nehmen wir einige Beispiele, um die Logik besser zu verstehen.

Kod:
int a = 10;

int *ptr = &a;

*ptr = 15;

Kod:
int b = 20;

int c = 30;

int *ptr2 = &b;

ptr2 = &c;

Können Sie den Unterschied zwischen den beiden Codes verstehen, die ich oben geschrieben habe?

Im ersten Code haben wir eine Variable mit dem Namen ptr-Zeiger erstellt, wobei die Adresse der Variablen a beibehalten und die Adresse des ptr-Zeigers mit dem Wert (*) 15 geändert wurde. Dieses Konzept befindet sich in der Adresse, die der Cursor hält (dh die Variable a ändert sich direkt).

Wenn wir zum zweiten Code kommen, erstellen wir zwei verschiedene Variablen mit den Namen b und c. Unser Zeiger mit dem Namen ptr2 enthält die Adresse der Variablen b. Später ändern wir den ptr2-Zeiger (wir haben keinen Zeiger verwendet, nicht das Innere), dh die Zeigervariable. Unser ptr2-Zeiger enthält nun die Adresse der Variablen c und nicht die Adresse der Variablen b.
 
Son düzenleme:

RichardJackson

Katılımcı Üye
13 Ocak 2018
700
1
Viyana
Cevap: [A bis Z] Lassen Sie uns C Programmiersprache lernen!

Das Verstehen des Punktes des Zeigers ist eigentlich die Bedeutung von 2 Zeichen. Kaufmännisches Und und Sternchen sind für dieses Thema sehr wichtig.

Am Anfang des Artikels haben wir angegeben, dass jede Variable einen Platz in Programmiersprachen einnimmt. Sind die von uns definierten Zeiger auch keine Variablen? Kurz gesagt, Zeiger nehmen auch einen Platz im Speicher ein. Mal sehen, wo sich der Zeiger im Speicher befindet.

Kod:
int x = 5;
int *p = &x;
int *p2 = &p;

Dies ist kein Hinweis, der von Nutzen ist. Niemand möchte wissen, an welcher Adresse sich der Zeiger befindet (außer in extremen Fällen). Hier habe ich eine solche Demonstration durchgeführt, um nur seine Logik zu beschreiben. In diesem Code befindet sich der p2-Zeiger auch in einem zufälligen Bereich auf dem RAM. Dies kann bis zu solchen Endlosschleifen gehen.

Es ist möglich, die Adresse einer Variablen anzuzeigen, ohne einen Zeiger zu definieren. Diese Verwendung ähnelt dem Drucken von Ganzzahlen ohne Definieren von Ganzzahlen.

Kod:
printf ("% d", 15); // Wir haben 15 gedruckt, ohne eine ganzzahlige Variable zu definieren.

int x = 5;
printf ("% p", & x); // Wir haben die Adresse von x angezeigt, ohne einen Zeiger zu definieren.


Wie wir sehen können, können wir die Adresse der x-Variablen sehen, ohne eine Zeigervariable erstellen zu müssen.

Kod:
int a = 50;
printf("%d", *&a);

Was passiert, wenn wir einen Nutzen daraus ziehen? Das kaufmännische Und-Zeichen bedeutete die Adresse der Variablen, und das Sternchen bedeutete innerhalb der Variablen.

Hier meinen wir also Drucken innerhalb der Adresse der Variablen a. Ich versuche hier nur, die Logik zu erklären. Diese Verwendung ist keine Verwendung, die Sie möglicherweise in Zukunft sehen werden. * Ein & direkt schreiben und ein direkt schreiben kommt zur gleichen Tür. Wenn ich a eingebe, wird die Variable a unterdrückt. Wenn wir * & a drucken, drucken wir indirekt die Variable (unnötig) a.

Suchen, kompilieren und vergleichen Sie die folgenden Ausgaben selbst:

Kod:
int a = 10;
int b = 20;
int c = 30;

int *p = &a;
*p = 15;
p = &c;
*p = b;

printf("%d", a);
printf("%d", b);
printf("%d", c);

Zeichenfolgen in C-Sprache (Char List)

In der C-Sprache nehmen Zeichenfolgen so viel Platz ein wie ihre Länge. Der Grund ist, dass jede Zeichenfolge ein Endzeichen hat. Nachdem die Zeichenfolge beendet ist, ist 0 das letzte Zeichen. Auf diese Weise versteht der Computer, wann die Zeichenfolgen fertig sind. Um eine Zeichenfolge in C zu definieren, müssen wir vorher bestimmen, wie viele Stellen sie haben wird. Ihm zufolge gibt es einen Platz für uns im Gedächtnis und wir können den Platz, den wir im Gedächtnis reservieren, nicht an anderer Stelle im Programm ändern.

Kod:
char name [10] = "Richard";

Wenn wir eine Beschreibung erstellen, können wir die Länge nicht ändern. Wenn wir die Länge überschreiten, wird beim Kompilieren des Programms eine Fehlermeldung angezeigt. Der Grund dafür ist, dass wir den für uns reservierten Raum verlassen.

String gehört nicht zu den grundlegenden Datentypen in der Sprache C. In der Tat sind Zeichenfolgen Listen von char-Datentypen. Wir können Zeichenfolgen verwenden, indem wir die Zeichenfolgenbibliothek einschließen, aber obwohl wir die Zeichenfolge dort schreiben, verwenden wir tatsächlich den maskierten Status der Zeichenfolgen.


Definieren einer Zeichenfolge mithilfe eines Zeigers

Wir wissen, dass Zeiger die Adresse bestimmter Variablen behalten. Wir haben gesagt, dass Strings auch Strings sind. Mit anderen Worten, jede Serie hat die Startadresse auf dem RAM, und da es char-Serien gibt, erhöht sie sich um 1 Byte und 1 Byte. Mit dem Zeiger können wir eine Zeichenfolge definieren, ohne anzugeben, wie viele Zeichenfolgen wir eingeben werden. Wenn wir eine Reihe mit dem Zeiger definieren möchten, verwenden wir die folgende Verwendung.

Definieren wir einen String mit dem Zeiger.

Kod:
char *name= "Richard";

Wir haben oben einen Zeiger mit dem Namen definiert. Es hielt uns einen zufälligen Platz in der Erinnerung (nennen wir diesen Ort 0x123). Unsere Erinnerung ist 0x123. Die Adresse 'E' ist vorhanden. 0x124. Die Adresse enthält ein 'm'-Zeichen, das' i'-Zeichen bei 0x125 und das 'r'-Zeichen bei 0x125. Wir haben gesagt, dass Strings 1 Byte mehr als ihre eigene Länge verwenden. Es gibt also ein ' 0'-Zeichen auf 0x126. Mal sehen, wie das passiert.

Kod:
char *name= "Richard";
if (*(name+4)=='')
{
printf("!!!!");
}

Im obigen Code haben wir mit dem Zeiger einen Speicher zugewiesen. Wie wir wissen, gehen wir, wenn wir Name + 4 sagen, 4 Bytes vom Namen entfernt, dh wir gehen zum Feld nach r in der Auftragszeichenfolge. Also der Endspezifizierer der Zeichenfolge. Wir sind uns nicht sicher, ob dies wirklich existiert oder nicht, und wir möchten, dass es im if-Zustand einen Beweis mit printf zeigt. Wenn Sie diesen Code in Ihrem Compiler schreiben und kompilieren !!!! Sie werden ausdrucken.

Definieren wir die Integer-Liste mit dem Zeiger.

Wir haben gesagt, dass die Zeichenfolgen eine Liste sind, sodass wir die Listen mithilfe des Zeigers definieren können. Wir verwenden int * -Arrays, um Listen mit dem Zeiger zu definieren.

Kod:
int * array = {1,2,3};
int Sequenz 2 [3];
Array 2 [0] = 1;

Ich habe im obigen Code zwei Verwendungen gezeigt. Versuchen wir nun, die Elemente der Ganzzahlliste mit dem Zeichenzeiger zu stören, indem wir eine Ganzzahlliste erstellen.

Kod:
int array [4];
Sequenz [4] = 10;
char * p = Array;
* (p + 12) = 150;

Im obigen Code definieren wir Arrays. Wir ändern das 5. Element der Reihe mit Hilfe des Zeigers. Ja, es ist schön, aber wie kann man das sagen? Da wir wissen, dass der ganzzahlige Datentyp 4 Byte beträgt, beträgt der char-Variablentyp 1 Byte. Wenn wir ein Integer-Array erstellen, werden 6 Boxen in Form von 4 Bytes und 4 Bytes auf dem RAM erstellt. Mit anderen Worten, in unserem Speicher werden insgesamt 24 Byte Speicherplatz erstellt. Um mit dem Zeichenzeiger auf das letzte Element zuzugreifen, müssen wir 4 mal 4 springen, da char 1 Byte ist. Wir versuchen, einen ganzzahligen Wert mit einem Char-Zeiger anzuzeigen. Denken wir also an 24 Boxen anstatt an 6 Boxen. Wenn wir zum 20. Feld kommen, befinden wir uns am Anfang des letzten Feldes gemäß der Integer-Liste, dh die Reihenfolge stimmt mit dem Element [5] überein und wir ändern es mit Hilfe des Zeigers. Wenn Sie es nicht glauben, führen Sie den Code aus.

9BW1U2.jpg


Wie auf dem Foto zu sehen, nimmt die Adresse in Form von 4-4 zu.

Der Punkt, auf den wir beim Definieren von Zeichenzeigern achten sollten, ist, dass Zeichenzeiger bis zu 1 Byte Daten speichern können. Was wir 1 Byte nennen, besteht aus 8 Bits (Binärziffer), die zusammenkommen. Insgesamt gibt es also 2 ^ 8 Möglichkeiten. Der Maximalwert eines Bytes muss 255 sein (wir schließen 0 in insgesamt 256 Werte ein). Wenn wir das Array [5] -Element mit Hilfe des Zeigers auf einen Wert größer als 255 ausgleichen möchten, liefert der Modus Ergebnisse gemäß 256. Lassen Sie uns alles zusammen sehen.

Kod:
int array [4];
Sequenz [3] = 10;
printf ("% d  n", Array [3]);
char * p = Array;
* (p + 12) = 256;
printf ("% i  n", Array [3]);
kurz * p2 = Array;
* (p2 + 6) = 25;
printf ("% i", Array [3]);

Wenn wir das 3. Element der Reihe unterdrücken wollen, gibt es 0 zurück. mod ist gleich 256 0 im Vergleich zu 256 weil :)

Außerdem wurde im obigen Code short verwendet, da short 2 Bytes beträgt, haben wir + 6 anstelle von + 12 verwendet. Wir können uns das als 6 Schritte zum kurzen Sprung zum Sprung vorstellen. kurz * 6 dh 2 * 6 = 12 Das Ergebnis ist das gleiche wie wir sehen können.



Strukturkonzept

Das Konzept, das wir Struct nennen, sind Datenstrukturen. Wir sagten, dass es hauptsächlich Datentypen int, float, double, char in der Sprache C gibt. Das wird uns natürlich nicht reichen. Wenn wir das Datum vom Benutzer erhalten möchten, müssen wir eine erweiterte Datenstruktur erstellen. Sie können diese Strukturen mit der Klassenstruktur in anderen Programmiersprachen vergleichen.

Kod:
struct cyber{
int a;
char b;
float c;
}


Ich habe oben eine Struktur namens Cyber ​​definiert. Diese Struktur enthält 3 Elemente aus verschiedenen Datentypen. Erstellen wir aus dieser Struktur eine Variable.

Kod:
struct cyber a;
a.a = 5;
a.b = 'a';
a.c = 5.12;

Ich habe aus dieser Struktur eine Variable erstellt und allen Elementen ein Element zugewiesen.

Lassen Sie uns eine Datumsstruktur erstellen, die erklärender ist

Kod:
Struktur datum {
int Monat;
int gun;
int Jahr;
}}


Lassen Sie uns die Struktur der Geschichte erstellen, unsere Aufgaben erledigen.

Kod:
Strukturdatum Mein Geburtstag;
Mein Geburtstag Monat = 10;
Mein Geburtstag Tag = 10;
Mein Geburtstag Jahr = 1999;

Wie Sie sehen können, können wir diese Daten ohne solche Verwirrung im Speicher behalten, wenn wir Daten im Datumsformat wünschen.

Wir können auch mit Typedef definieren, was bevorzugter ist. Weil es in der Syntax einfacher ist.

Kod:
typedef unsigned long long ULL;

Wie Sie sehen können, habe ich den Typ Unsigned long long mit typedef selbst neu definiert. Es hat die Benutzerfreundlichkeit erhöht, wir können dies auch für Strukturen tun.

Kod:
typedef struct a{
char a;
}

Kod:
ein Variablenname;

Funktionen in C-Sprache

Funktionen sind Konzepte, die entstanden sind, weil es für uns schwierig wäre, immer wieder denselben Algorithmus zu schreiben, wenn wir mehr als eine Operation mit diesem Programm ausführen. Sie können Werte oder Werte in die Funktionsstruktur aufnehmen und einen Wert zurückgeben, indem sie gemäß bestimmten Werten gemäß diesen Werten verarbeiten. Bei der Deklaration von Funktionen müssen wir zuerst schreiben, welche Art von Wert zurückgegeben werden soll. Wir definieren eine Funktion vom Typ ****, wenn sie keinen Wert zurückgibt (wenn sie eine Ausgabe schreibt oder nach innen tauscht). Definieren wir eine Funktion.

Kod:
**** myFunc ()
{
printf ("Ich bin eine Funktion !!");
}}

Wir haben hier eine Funktionsdefinition gemacht. Wenn die Funktionsdefinition über dem Funktionsaufruf erfolgt, müssen wir den Funktionsprototyp definieren.

Warum sollten wir so etwas tun?
Weil der Compiler die Codes von oben nach unten liest. Es wird in Ordnung gehen. Wenn es um die Zeile myFunc () geht, wird "Ich kenne dich nicht" angezeigt, da diese Definition noch nicht gesehen wurde. Deshalb definieren wir Prototypen. Sie wird normalerweise direkt unter dem Prototyp der Präprozessor-Direktiven definiert. Schauen wir uns Ihr Beispiel an.

Kod:
#include <stdio.h>
**** myFunc();

Wenn der Compiler diesen Prototyp sieht, überspringt er die Zeile und gibt die Zeile zurück, in der wir die Funktion definieren. Er wird die Definition machen und dorthin zurückkehren, wo er war.

Parameter für die Funktion angeben?

Die Funktion kann bestimmte Nummern von uns anfordern, um bestimmte Algorithmen zu bearbeiten. Nehmen wir zum Beispiel an, wir schreiben die Funktion add. Um a + b hinzuzufügen, aber was sind unsere a- und b-Werte, müssen diese Werte spezifisch sein, um eine dynamische Struktur zu erstellen. Wir wollen 5 zu 3 addieren. Unser Wert von 5 wird durch a ersetzt, und unser Wert von 3 wird durch b ersetzt.

Kod:
Summe int (int a, int b)
{
return a + b;
}}

Jetzt sammeln wir 2 verschiedene Zahlen in dem Code, den ich oben geschrieben habe. Lassen Sie uns dieses Konzept erklären, wir sehen hier ein Rückwort.

Was macht es und warum benutzen wir es?

Wenn wir die Funktion aufrufen, erstellen wir temporäre Variablen auf dem RAM. In dem von uns aufgerufenen Abschnitt (int a, int b) treten die Variablen a und b zur Laufzeit der Funktion auf. Wenn die Funktion beendet ist, werden die Variablen gelöscht. Das Programm erkennt diese Variable nicht (wir können eine statische Variable erstellen, indem wir am Anfang der Variablen statisch sagen, damit sie nicht gelöscht wird. Dies ist ein weiteres Problem). Hierfür wird das Konzept der Rückgabe verwendet, es bedeutet, etwas zurückzugeben.

Kurz gesagt, Sie löschen die Variablen, die ich erstellt habe, mein Bruder. Ich habe nur noch 5 und 3 davon gesammelt. Lassen Sie uns das Beispiel erklären. Wir haben 5 gesammelt und 3 Variablen a und b werden gelöscht. Wir können die Funktion, die wir als (3, 5) aufrufen, einer Variablen zuweisen oder sie direkt mit Hilfe von printf drucken.

Kod:
int main ()
{
int c;
c = Summe (a, b);

}}

Summe int (int a, int b)
{
return a + b;
}}

Im obigen Code ist der Wert in meiner Variablen c der von der Funktion zurückgegebene Wert. Aus diesem Grund verwenden wir return.


Call By Value

In Funktionen, bei denen wir per Aufruf Wert als Parameter nehmen, wird eine Variable erstellt, die Funktion endet und die Variable wird gelöscht. In diesem Fall ist mein x-Wert 4, mein y-Wert 7. Wenn ich diese Variablen durch andere ersetzen möchte (x = 7 y = 4), wäre es falsch, wenn ich sie mit der Methode call by value aufrufe.


Warum sollte es falsch sein?

Da die Parameter, die ich an die Funktion sende, ihre eigenen Variablen erstellen, ändern Sie sie in sich selbst und löschen Sie diese Variablen aus dem Speicher. Was übrigbleibt? Nichts....

Beispielfunktion

Kod:
int main()
{
int x = 4, y=7;
swap(x,y);

}
int swap(int x, int y)
{
int tmp;
tmp = x;
x = y;
y = tmp;
}

Der Code, den ich oben geschrieben habe, ändert die Werte nicht. Weil der Teil (int x, int y), den ich in den Funktionsparameter geschrieben habe, nur eine Notation ist. Selbst wenn wir dieselben Variablennamen schreiben, erstellen sie eine separate Variable und geben sie dann aus dem Speicher frei. Daher sollten wir uns für diese Art von Problem auf die Methode beziehen, die wir call by reference aufrufen.

Call By Reference

Wenn Sie Anruf mit Referenz sagen, ist dies als Wort möglicherweise nicht sehr sinnvoll. Wenn Sie sagen, dass Sie mit einem Zeiger anrufen, wird dies in Ihrem Kopf deutlicher. Wenn wir die Funktion als Parameter adressieren, geht die Funktion an diese Adresse, da sie selbst keine Adresse erstellen kann. Es verarbeitet die Adresse. Wenn diese Adresse unsere x- und y-Werte sind, wird sie kurz erfolgreich ausgetauscht.

Kod:
int main()
{
int x = 4, y=7;
swap(&x, &y);

}
int swap(int *x, int *y)
{
int tmp;
tmp = *x;
*x = *y;
*y = tmp;
}

Wir sollten nicht vergessen, das kaufmännische Und-Zeichen (&) zu setzen, da es sich um die Adresse handelt. Bei der Verarbeitung von Arrays verwenden wir Call-by-Reference. Da die Arrays eine Adresse angeben, definieren wir sie als int arra [10]. Wenn wir versuchen, ein Array mit printf zu drucken, wird die Adresse des ersten Index des Arrays zurückgegeben. Alle Operationen, die in Zeigern ausgeführt werden können, können auch in Reihe ausgeführt werden.


Rekursive Funktion

Diese Arten von Funktionen sind selbstaufrufende Funktionen. Die Verwendung dieser Art von Funktion ist sehr riskant. Wenn wir die Funktionsschleife nicht verlassen, füllt sich der Stapelspeicher und es kann zu einem Stapelüberlauffehler kommen (Segmentierungsfehler: 11). Es sollte mit Vorsicht verwendet werden.

Kod:
#include <stdio.h>
int prime (int number, int i);
int main (int argc, char const * argv [])
{
int n, Kontrolle;
printf ("Zahlen eingeben  n");
scanf ("% d", & n);
für (int i = 2; i <n; ++ i)
{
Kontrolle = Primzahl (i, i / 2);
if (control == 1)
{
printf ("% d  n", i);
}}
}}
return 0;
}}

int prime (int number, int i)
{
if (i == 1)
{
return 1;
}}
sonst wenn (Zahl% i == 0)
{
return 0;
}}
sonst
{
Primzahl zurückgeben (Zahl, i-1);
}}
}}

In dem Code, den ich oben geschrieben habe, habe ich das Beispiel der rekursiven Funktion gemacht, mit der wir eine Primzahl finden können. Beachten Sie, dass sich meine Rückruffunktion unter einem Bedingungsblock befindet. Dadurch wird verhindert, dass sich die Funktion für immer selbst aufruft (bis der Stapelspeicherplatz voll ist).

Da dieses Thema ein sehr verwirrendes Beispiel ist, möchte ich noch ein Beispiel nennen.

Kod:
#include <stdio.h>
#include <stdlib.h>
int fibonacci (int n);
int main (int argc, char const * argv [])
{
   System ("klar");
   int x;
   printf ("wie viele Ziffern sind Fibonacci:");
   scanf ("% d", & x);
   printf (" nFibonacci-Array:  n  n");
   für (int i = 0; i <x; ++ i)
   {
     printf ("4d", Fibonacci (i));
   }}
   printf (" n  n  n");


   return 0;
}}

int fibonacci (int n)
{
   if (n == 0)
   {
     return 0;
   }}
   sonst wenn (n == 1)
   {
     return 1;
   }}
   sonst
   {
     Rückkehr (Fibonacci (n-2) + Fibonacci (n-1));
   }}
}}

Dieser Code wird auch verwendet, um die Fibonacci-Sequenz in dem vom Benutzer eingegebenen Schritt zu drucken.



Dynamische Speicherverwaltung

Was ist das Konzept, das wir dynamische Speicherverwaltung nennen? Lassen Sie uns zuerst darüber sprechen. Es gibt keine Klassen in C-Sprache, wir erwarten, dass der Programmierer jeden Prozess selbst durchführt. Wenn wir ein Beispiel aus dem Einfachsten geben, wenn wir eine Reihe von 5 Elementen definieren und verstehen, dass dies in der Mitte des Programms nicht ausreicht, was tun wir dann? Nach unserem derzeitigen Kenntnisstand können wir eine solche Lösung entwickeln. Wir werfen das 5-Element-Array in den Papierkorb, erstellen ein 10-Element-Array, mit der for-Schleife weisen wir jedes Element des Arrays unserem neuen Array zu. Wir beschäftigen uns mit Erinnerung. Dies ist keine logische Lösung, wir müssen dynamischere Lösungen finden. Bevor ich auf das Thema eingehe, möchte ich über das Konzept von Stapel und Haufen sprechen.

Was ist ein Stapel?


Der Stapel ist der Arbeitsbereich des Programms im Speicher. Wenn wir das Programm ausführen, weist uns das Betriebssystem auf dem RAM eine Zone für den Arbeitsbereich des Programms zu. Wir können diese Region statisch verwenden. Wir verwenden Variablen, die sich hier wahrscheinlich nicht ändern. Betrachten wir Stacki als Liste. Es funktioniert mit der Logik von First-In-Last-Out. Unsere Variablen werden nacheinander erstellt. Lassen Sie uns das Beispiel zeigen.

Kod:
#include <stdio.h>

int main ()
{
int x = 4;
int array [5] = {1,2,3,4,5};
}}

Meine beiden Variablen im obigen Code werden im Stapelbereich gespeichert. Während der Kompilierung wird berechnet, wie viel Platz sie im Stapelbereich beanspruchen. Werfen wir einen Blick auf die Serie. Beim Kompilieren gibt der Compiler an, dass das Array 5 Elemente enthält. Das Ereignis ist dort drüben, wir haben diese Serie mit 5 Elementen definiert, wir können sie nicht mehr verwenden.



Was ist Haufen?

Der Heap-Bereich befindet sich außerhalb des Arbeitsbereichs des Programms. Beim Versuch, Platz zu sparen, haben wir die Möglichkeit, auf den vom Betriebssystem oder einem anderen Programm verwendeten Speicherplatz zu stoßen. Wenn wir auf eine dieser Adressen stoßen, wird NULL zurückgegeben.

Was ist diese NULL-Adresse?

Ich wollte 5 Bytes Speicher über den Heap vom Betriebssystem. Wenn es sich um einen Bereich handelt, den das Betriebssystem verwendet, kann es mir diesen Bereich nicht geben. Ich verwende ihn, mein Bruder. Gegebenenfalls kann er. Programmierer haben das 0. Byte des Computerspeichers als NULL-Wert zugewiesen, dh als verbotene Zone, um dieses Problem zu lösen. Wenn wir also auf den vom Betriebssystem verwendeten Speicherplatz stoßen, werden wir auf 0 Byte geleitet. Wir können nicht eintreten, da es sich um einen eingeschränkten Bereich handelt und der Speicherbereich nicht erfasst werden kann.

Nachdem wir das Heap-Feld verwendet haben, müssen wir es an das Betriebssystem zurückgeben. Wenn wir es nicht zurückgeben, wird dieses Feld weiterhin verwendet, was zur Speicherbelegung führt. Dies bringt das Konzept des Speicherverlusts mit sich, den wir Speicherverlust nennen. Wenn das Programm langsamer wird, wenn Sie ein Spiel oder Programm für längere Zeit verwenden, hat der Programmierer, der an der dynamischen Speicherverwaltung in diesem Programm interessiert ist, eine unvollständige Codierung vorgenommen. Er gab die von ihm verwendeten Bereiche nicht zurück und kehrte zum Betriebssystem zurück. Im Laufe der Zeit schwoll der Speicher an und das Spiel / Programm wurde langsamer. Im Gegensatz zu anderen Sprachen gibt es in der Sprache C keinen Garbage Collector.


Was ist das für ein Müllsammler?

Wenn wir es auf Deutsch nennen, ist es der Garbage Collection-Mechanismus. Nach dem Sammeln eines Speicherbereichs im Heap-Bereich kehrt dieser Mechanismus automatisch zum Betriebssystem zurück, wenn wir mit diesem Bereich fertig sind. Diese Funktion ist in der Sprache C nicht verfügbar. Dies muss vom Programmierer durchgeführt werden.

Stapeleigenschaften

* Es ist schneller als der Heap-Bereich.
* Die erstellten Variablen werden automatisch an das Betriebssystem zurückgegeben.
* Es ist nicht dynamisch.
* Die Dimensionen der Kompilierungszeit werden berechnet.


Heap-Funktionen

* Es ist langsamer als der Stapelbereich.
* Da es in der Sprache C keinen Garbage Collector gibt, wird vom Programmierer erwartet, dass er den Rückerstattungsprozess abschließt.
* Es ist dynamisch.
* Die Laufzeit wird berechnet und dem angegebenen Speicherbereich zugeordnet.


Während primitive Datentypen auf dem Stapel gespeichert bleiben, sind Referenzdatentypen auf dem Heap verfügbar. Die Referenz, die den Referenzdatentyp angibt, wird ebenfalls auf dem Stapel gespeichert.


RxfBOL.png


Wie auf dem Foto zu sehen ist, wird der Referenzwert (Adresswert) über unserem Zahlenwert gehalten. Die angegebene Adresse wird im Heap-Bereich gespeichert.


malloc () Funktion

Die Malloc-Funktion wird verwendet, um Speicherplatz vom Heap-Speicherplatz zu sammeln. Es braucht einen einzigen Parameter. Die Verwendung erfolgt wie im Beispiel.

Kod:
int *p = malloc(5*4);

Obwohl die obige Verwendung korrekt ist, wird sie für die Verwendung nicht empfohlen. Hier haben wir Platz für eine Reihe von 5 Ganzzahlen zugewiesen, aber wir hätten dies verwenden sollen, da die Ganzzahlgröße von System zu System variieren kann.

Kod:
int *p = malloc(5*sizeof(int));

In einigen Quellen wird die Malloc-Funktion vor ihrer Verwendung in den Integer-Zeiger konvertiert. Selbst wenn wir dies nicht tun, wird der Integer-Zeiger automatisch konvertiert, da wir ihn int * p nennen. Also was ich meine ist;

Kod:
int *p = (int*)malloc(5*(sizeof(int));

Kod:
int *p = malloc(5*sizeof(int));

Die beiden obigen Codes sind gleich. Die Malloc-Funktion berechnet uns bis zu 20 Byte Heap-Speicherplatz. Das Wort Bedeutung kommt aus dem Speicher zuweisen. Deutsch bedeutet Speicherzuweisung.


calloc () Funktion


Die Calloc-Funktion ist der Malloc-Funktion sehr ähnlich. Der einzige Unterschied ist, dass es diese Erinnerung löscht und uns gibt. Es läuft also langsamer als die Malloc-Funktion. Was verstehen wir unter Reinigung? Setzt den Wert 0 in alle Werte, und wenn wir mit malloc Speicherplatz zuweisen, gibt es Müllwerte.

Kod:
int *p = calloc(5,sizeof(int));

Als zweiten Unterschied nimmt diese Funktion 2 Parameter an. Wenn wir in der Malloc-Funktion 5 * sizeof (int) sagen, müssen wir hier 5, sizeof (int) sagen.


realloc () Funktion



Die Funktion realloc () wird verwendet, um Speicherplatz neu zuzuweisen, wenn der Speicher nicht ausreicht. Es werden 2 verschiedene Parameter benötigt. Der erste Parameter fordert die Adresse an, der zweite Parameter fordert die neue Größe an.

Kod:
int *p = malloc(5*sizeof(int));

Wir haben Malloc Platz zugewiesen und wenn dieser Platz nicht genug für uns war;

Kod:
int *p2 = realloc(p, 10*sizeof(int));

In der Form vergrößern wir diesen Bereich auf 40 Bytes.

Freie () Funktion

Zu Beginn der Episode erwähnte ich das Konzept des Speicherverlusts. Der Grund, warum dieses Konzept auftritt, liegt in der unvollständigen oder falschen Verwendung dieser Funktion. Wenn wir mit einem Speicherplatz fertig sind, müssen wir diesen Speicherplatz an das Betriebssystem zurückgeben. Der Grund dafür ist, dass es in der C-Sprache keinen Garbage Collector-Mechanismus gibt. Die Funktion, mit der wir den Speicherplatz an das Betriebssystem zurückgeben können, ist die Funktion free ().

Kod:
free(p);

Da wir mit dem obigen p-Indikator fertig sind, haben wir ihn an das Betriebssystem zurückgegeben.

Konzept des Ausdrucks

Das Konzept des Ausdrucks ist das zugrunde liegende Konzept der Programmiersprache. Es bedeutet Ausdruck in der türkischen Definition. Es ist in zwei verschiedene Zweige unterteilt: L-Wert-Ausdruck und R-Wert-Ausdruck.

L-Wert-Ausdruck

Wir wissen, dass bei der Programmierung der Ausdruck dem Zuweisungsoperator entspricht. Dies bedeutet, dass Sie den Wert rechts nach links zuweisen. Der Wert links muss immer ein L-Wert-Ausdruck sein. Der L-Wert-Ausdruck ist einfach ein Variablenname. Es kann keinen festen Ausdruck oder Operator geben (z. B. + 5).

Zum Beispiel;

a + c ist kein lWert-Ausdruck. Es kann als Einzel- oder Wertausdruck allein gezählt werden.



R-Wert-Ausdruck
Der Ausdruck der rechten Seite kann alles sein. Weil wir gesagt haben, dass es die Regel gibt, dass die rechte Seite der linken Seite zugeordnet ist. Nur konstante Werte sind auch R-Wert-Ausdrücke.

Zum Beispiel;

Viele Beispiele wie 15, a + b, a, 15/5 können gezählt werden.




Gewerkschaftsstruktur



Die Unionsstruktur ist eine Struktur, die der Strukturstruktur sehr ähnlich ist. Es wird in der Socket-Kommunikation verwendet. Es wird verwendet, um eingehende Pakete leicht aufzubrechen. Seine Definition ist genau wie struct. Die Größe basiert jedoch auf der Größe des größten darin enthaltenen Datentyps. Alle darin enthaltenen Variablen verwenden dieses Feld gemeinsam.

Kod:
union{
int a;
char a,b,c,d;
}myUnion;

Da der Datentyp, der den größten Bereich im obigen Code abdeckt, eine Ganzzahl ist, beträgt die Größe unserer Datenstruktur mit dem Namen myUnion 4 Byte.

S21GKL.png


Sie können die Arbeitslogik der Vereinigung im obigen Bild leicht verstehen.

Identifizierung der Zeigerstruktur


Aus diesem Datentyp können wir eine Struktur erstellen und einen Zeiger definieren. Der einzige Unterschied besteht darin, dass beim Zugriff auf die Elemente das Pfeilzeichen (->) und nicht der Punkt (.) Verwendet wird. Ich bin sicher, Sie werden es sehr gut verstehen, wenn ich Ihnen das Beispiel zeige.

LKIIW8.png


Ausgabe des Programms:

WS523R.png


Arbeitslogik des Programms:

Die Struktur x Struktur, die ich erstellt habe, nimmt 4 Byte Speicherplatz ein. Weil es insgesamt vier Zeichenvariablen gibt. Wir versuchen, diese Struktur als Zeiger zu verwenden. Wieder zeigen wir den ganzzahligen Wert, der mit diesem Zeiger vier Bytes belegt. Unser ganzzahliger Wert ist 1028.
Wenn wir diesen Wert in hexadezimaler Basis schreiben;

0x00000404 (Adresswerte werden in 8-Byte-, 64-Bit- und 64-Bit-Prozessoren adressiert. Wir setzen diese Nullen entsprechend)
Es wird gleich dieser Zahl sein.

Da das Zeichen 1 Byte anzeigt, schreiben wir 1 Byte für den Wert von a, der 0 und 4 ist. Weil dieses Problem hexadezimal ist. Wenn Sie hier nicht verstehen, empfehle ich Ihnen, sich die Zahlengrundlagen in der Mathematik anzusehen.

Kurz:
a = 04
b = 04
c = 00
d = 00


Zufälligen Wert generieren


Tatsächlich können Computer keine echten Zufallswerte erzeugen. Es hat einen bestimmten Algorithmus. Dies bringt Probleme mit sich. Dieser Algorithmus beginnt nach einer bestimmten Zahl kontinuierlich dieselben Werte zu erzeugen. Dieser Algorithmus hat einen Suchwert (Root-Wert). Wenn wir dies nicht ändern, werden wir feststellen, dass das Programm nach dem Kompilieren bei unserem zweiten Aufruf dieselben Werte generiert. Als Lösung hierfür müssen wir den Suchwert bei jedem Start mit der Funktion srand () seekrandom ändern. Wenn ich in diesen srand () einen Zeitwert eingebe, bedeutet dies, dass ich bei jedem Öffnen des Programms möglicherweise einen zufälligen Wert generiert habe. Weil sich die Zeit ständig ändert. Ich denke, Sie verstehen die Logik der Srand () - Funktion. Sie können dieser Funktion die Parameter srand (Zeit (0)) oder srand (Clock ()) zuweisen. Die Zeit beträgt 0 Sekunden. Die Uhr basiert auf Sekunden.

Wenn wir den Suchwert bei jedem Start geändert haben, können wir jetzt zu unserer Funktion rand () wechseln. Die Rand-Funktion erzeugt riesige Werte. Wir müssen den Mod mit unseren eigenen Händen nehmen. Mathematisch lautet die Regel wie folgt:

Zahlen im geschlossenen Min-Max-Bereich zu generieren

rand ()% (max-min + 1) + min

Wir müssen dem Prozess folgen. Um die Uhr- oder Zeitfunktion verwenden zu können, müssen wir die Header-Datei time.h in unseren Code aufnehmen.

Kod:
int main ()
{
srand (clock ());
int array [10];
für (int i = 0; i <10; ++ i)
     {
         Array [i] = rand ()% (10-0 + 1) +0;
     }}
}}

Der obige Code generiert 10 Zahlen, einschließlich 10, im Bereich von 0 bis 10 und sendet sie an die Serie mit dem Namen series.


C Programmier-Tricks


Im letzten Teil des Ortes werde ich über kleine Tricks sprechen, die ich ausführlich sagen kann, die Sie möglicherweise in Interviews antreffen und die Sie an den meisten Orten nicht sehen können.

1) Wenn wir den Zuweisungsoperator anstelle des Logikoperators in der Schleife oder Entscheidungsstruktur verwenden, wird der R-Wert-Wert des Zuweisungsoperators zurückgegeben.

Stichprobe:


6BSAfa.png


2) Der letzte Operator, der in einer Transaktion ausgeführt wird, ist der Zuweisungsoperator. Dies ist sehr wichtig, da möglicherweise irreführende Fragen auftauchen.

Hier ist die irreführende Frage:


e7yJW9.png


3) Bitsel und Normal und Bediener sollten nicht verwechselt werden! Auch wenn es bitweise und das erste falsch ist, sieht es sich Teil 2 an. Es ist normal und sieht nicht aus.

P0J0RI.png



4) Da die Verwendung von ++ und - gleich x + = 1 ist, kann dies nicht für die Zahl durchgeführt werden.


MLNdef.png


5) Das ^ -Zeichen ist ein EXOR-Anschluss. Führt bitweise Operationen durch. Gibt 1 zurück, wenn es gleich ist, 1, wenn es anders ist.

277LPd.png


6) Die Printf-Funktion gibt auch 1 mehr als die Anzahl der darin enthaltenen Zeichen zurück.

277LPd.png


7) Wir können mit dem Zeigeroperator auf die Arrays und mit dem Array-Index ([]) auf die Arrays zugreifen.

xMBKNK.png


8) Wenn Sie (?) Operator in einer Zeile verwenden

KbxMML.png


9) Die Schatzvariablen, die wir dem Präprozessor geben, werden nicht verarbeitet. Es fungiert als Kopierpaste.

V6MeA8.png


 

R4V3N

Kadim Üye
3 Tem 2016
6,061
1
23
Wow everybody is speaking Deutsch, ffs we can't find anyone knows English for our team. :trl
Nice topic tho :)
 

THT SON MESAJLAR

Üst

Turkhackteam.org internet sitesi 5651 sayılı kanun’un 2. maddesinin 1. fıkrasının m) bendi ile aynı kanunun 5. maddesi kapsamında "Yer Sağlayıcı" konumundadır. İçerikler ön onay olmaksızın tamamen kullanıcılar tarafından oluşturulmaktadır. Turkhackteam.org; Yer sağlayıcı olarak, kullanıcılar tarafından oluşturulan içeriği ya da hukuka aykırı paylaşımı kontrol etmekle ya da araştırmakla yükümlü değildir. Türkhackteam saldırı timleri Türk sitelerine hiçbir zararlı faaliyette bulunmaz. Türkhackteam üyelerinin yaptığı bireysel hack faaliyetlerinden Türkhackteam sorumlu değildir. Sitelerinize Türkhackteam ismi kullanılarak hack faaliyetinde bulunulursa, site-sunucu erişim loglarından bu faaliyeti gerçekleştiren ip adresini tespit edip diğer kanıtlarla birlikte savcılığa suç duyurusunda bulununuz.