Ein Datentyp gibt den Datentyp an, den eine Variable speichern kann, z. B. Ganzzahl, Gleitkommazahl, Zeichen usw.

Es gibt die folgenden Datentypen in der C-Sprache.

Grundlegende Datentypen

Die grundlegenden Datentypen sind Ganzzahl- und Gleitkomma-Datentypen. Die Sprache C unterstützt sowohl vorzeichenbehaftete als auch vorzeichenlose Literale.

Die Speichergröße der Basisdatentypen kann sich je nach 32- oder 64-Bit-Betriebssystem ändern.

Nachteile des Online-Bankings

Sehen wir uns die grundlegenden Datentypen an. Seine Größe ist angegeben nach 32-Bit-Architektur .

Int:

Ganze Zahlen sind ganze Zahlen ohne Bruch- oder Dezimalteile, und die int-Datentyp wird verwendet, um sie darzustellen.

Es wird häufig auf Variablen angewendet, die umfassen Werte , wie zum Beispiel Zählungen, Indizes oder andere numerische Zahlen. Der int-Datentyp kann beides darstellen positiv Und negative Zahlen weil es standardmäßig signiert ist.

Ein int nimmt auf 4 Bytes Auf den meisten Geräten ist ausreichend Speicher vorhanden, sodass Werte zwischen etwa -2 und +2 Milliarden gespeichert werden können.

Verkohlen:

Einzelne Charaktere werden durch die dargestellt char-Datentyp . Wird normalerweise zum Halten verwendet ASCII oder Zeichen des UTF-8-Codierungsschemas , wie zum Beispiel Buchstaben, Zahlen, Symbole , oder Kommas . Es gibt 256 Zeichen das kann durch ein einzelnes Zeichen dargestellt werden, das ein Byte Speicher beansprucht. Charaktere wie 'A', 'b', '5', oder '$' werden in einfache Anführungszeichen gesetzt.

Schweben:

Um ganze Zahlen darzustellen, verwenden Sie die Floating-Datentyp . Gleitkommazahlen können verwendet werden, um gebrochene Einheiten oder Zahlen mit Dezimalstellen darzustellen.

Der Float-Typ wird normalerweise für Variablen verwendet, die eine sehr gute Präzision erfordern, aber möglicherweise nicht sehr präzise sind. Es kann Werte mit einer Genauigkeit von ca. speichern 6 Dezimalstellen und eine Reihe von ca 3,4 x 1038 In 4 Bytes der Erinnerung.

Doppelt:

Verwenden Sie zur Darstellung zwei Datentypen zwei Gleitkommazahlen . Wenn zusätzliche Präzision erforderlich ist, beispielsweise bei wissenschaftlichen Berechnungen oder Finanzanwendungen, bietet es eine höhere Genauigkeit als Float.

Doppelter Typ , das verwendet 8 Byte Speicherkapazität und hat eine Genauigkeit von ca 15 Dezimalstellen ergeben größere Werte . C behandelt Gleitkommazahlen standardmäßig als Doubles, wenn kein expliziter Typ angegeben wird.

 int age = 25; char grade = 'A'; float temperature = 98.6; double pi = 3.14159265359; 

Im obigen Beispiel deklarieren wir vier Variablen: an int-Variable für das Alter der Person, a char-Variable für die Note des Schülers, a Float-Variable für die Temperaturmessung und zwei Variablen für die Zahl pi.

Abgeleiteter Datentyp

Über die grundlegenden Datentypen hinaus unterstützt C auch abgeleitete Datentypen, einschließlich Arrays, Zeiger, Strukturen, Und Gewerkschaften . Diese Datentypen geben Programmierern die Möglichkeit, heterogene Daten zu verarbeiten, den Speicher direkt zu ändern und komplizierte Datenstrukturen aufzubauen.

Array:

Ein Array, ein abgeleiteter Datentyp , ermöglicht Ihnen das Speichern einer Sequenz von Elemente mit fester Größe vom gleichen Typ. Es bietet einen Mechanismus zum Zusammenführen mehrerer Ziele derselben Daten unter demselben Namen.

Der Index wird verwendet, um auf die Elemente des Arrays zuzugreifen, mit a 0-Index für den ersten Eintrag. Die Größe des Arrays ist zum Zeitpunkt der Deklaration festgelegt und kann während der Programmausführung nicht geändert werden. Die Array-Komponenten werden in benachbarten Speicherbereichen platziert.

Hier ist ein Beispiel für die Deklaration und Verwendung eines Arrays:

HTML-Listenfeld

 #include int main() { int numbers[5]; // Declares an integer array with a size of 5 elements // Assign values to the array elements numbers[0] = 10; numbers[1] = 20; numbers[2] = 30; numbers[3] = 40; numbers[4] = 50; // Display the values stored in the array printf(&apos;Values in the array: &apos;); for (int i = 0; i <5; i++) { printf('%d ', numbers[i]); } printf('
'); return 0; < pre> <p> <strong>Output:</strong> </p> <pre> Values in the array: 10 20 30 40 50 </pre> <h3>Pointer:</h3> <p>A <strong> <em>pointer</em> </strong> is a derived data type that keeps track of another data type&apos;s memory address. When a <strong> <em>pointer</em> </strong> is declared, the <strong> <em>data type</em> </strong> it refers to is <strong> <em>stated first</em> </strong> , and then the <strong> <em>variable name</em> </strong> is preceded by <strong> <em>an asterisk (*)</em> </strong> .</p> <p>You can have incorrect access and change the value of variable using pointers by specifying the memory address of the variable. <strong> <em>Pointers</em> </strong> are commonly used in <strong> <em>tasks</em> </strong> such as <strong> <em>function pointers, data structures</em> </strong> , and <strong> <em>dynamic memory allocation</em> </strong> .</p> <p>Here is an example of declaring and employing a pointer:</p> <pre> #include int main() { int num = 42; // An integer variable int *ptr; // Declares a pointer to an integer ptr = # // Assigns the address of &apos;num&apos; to the pointer // Accessing the value of &apos;num&apos; using the pointer printf(&apos;Value of num: %d
&apos;, *ptr); return 0; } </pre> <p> <strong>Output:</strong> </p> <pre> Value of num: 42 </pre> <h3>Structure:</h3> <p>A structure is a derived data type that enables the creation of composite data types by allowing the grouping of many data types under a single name. It gives you the ability to create your own unique data structures by fusing together variables of various sorts.</p> <ol class="points"> <li>A structure&apos;s members or fields are used to refer to each variable within it.</li> <li>Any data type, including different structures, can be a member of a structure.</li> <li>A structure&apos;s members can be accessed by using the dot (.) operator.</li> </ol> <p>A declaration and use of a structure is demonstrated here:</p> <pre> #include #include // Define a structure representing a person struct Person { char name[50]; int age; float height; }; int main() { // Declare a variable of type struct Person struct Person person1; // Assign values to the structure members strcpy(person1.name, &apos;John Doe&apos;); person1.age = 30; person1.height = 1.8; // Accessing the structure members printf(&apos;Name: %s
&apos;, person1.name); printf(&apos;Age: %d
&apos;, person1.age); printf(&apos;Height: %.2f
&apos;, person1.height); return 0; } </pre> <p> <strong>Output:</strong> </p> <pre> Name: John Doe Age: 30 Height: 1.80 </pre> <h3>Union:</h3> <p>A derived data type called a <strong> <em>union</em> </strong> enables you to store various data types in the same memory address. In contrast to structures, where each member has a separate memory space, members of a union all share a single memory space. A value can only be held by one member of a union at any given moment. When you need to represent many data types interchangeably, unions come in handy. Like structures, you can access the members of a union by using the <strong> <em>dot (.)</em> </strong> operator.</p> <p>Here is an example of a union being declared and used:</p> <pre> #include // Define a union representing a numeric value union NumericValue { int intValue; float floatValue; char stringValue[20]; }; int main() { // Declare a variable of type union NumericValue union NumericValue value; // Assign a value to the union value.intValue = 42; // Accessing the union members printf(&apos;Integer Value: %d
&apos;, value.intValue); // Assigning a different value to the union value.floatValue = 3.14; // Accessing the union members printf(&apos;Float Value: %.2f
&apos;, value.floatValue); return 0; } </pre> <p> <strong>Output:</strong> </p> <pre> Integer Value: 42 Float Value: 3.14 </pre> <h2>Enumeration Data Type</h2> <p>A set of named constants or <strong> <em>enumerators</em> </strong> that represent a collection of connected values can be defined in C using the <strong> <em>enumeration data type (enum). Enumerations</em> </strong> give you the means to give names that make sense to a group of integral values, which makes your code easier to read and maintain. </p> <p>Here is an example of how to define and use an enumeration in C:</p> <pre> #include // Define an enumeration for days of the week enum DaysOfWeek { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }; int main() { // Declare a variable of type enum DaysOfWeek enum DaysOfWeek today; // Assign a value from the enumeration today = Wednesday; // Accessing the enumeration value printf(&apos;Today is %d
&apos;, today); return 0; } </pre> <p> <strong>Output:</strong> </p> <pre> Today is 2 </pre> <h2>Void Data Type</h2> <p>The <strong> <em>void data type</em> </strong> in the C language is used to denote the lack of a particular type. <strong> <em>Function return types, function parameters</em> </strong> , and <strong> <em>pointers</em> </strong> are three situations where it is frequently utilized.</p> <h3>Function Return Type:</h3> <p>A <strong> <em>void return type</em> </strong> function does not produce a value. A <strong> <em>void function</em> </strong> executes a task or action and ends rather than returning a value.</p> <p> <strong>Example:</strong> </p> <pre> void printHello() { printf(&apos;Hello, world!
&apos;); } </pre> <h3>Function Parameters: </h3> <p>The <strong> <em>parameter void</em> </strong> can be used to indicate that a function accepts no arguments.</p> <p> <strong>Example:</strong> </p> <pre> void processInput(void) { /* Function logic */ } </pre> <h3>Pointers:</h3> <p>Any address can be stored in a pointer of type <strong> <em>void*</em> </strong> , making it a universal pointer. It offers a method for working with pointers to ambiguous or atypical types.</p> <p> <strong>Example:</strong> </p> <pre> void* dataPtr; </pre> <p>The <strong> <em>void data type</em> </strong> is helpful for defining functions that don&apos;t accept any arguments when working with generic pointers or when you wish to signal that a function doesn&apos;t return a value. It is significant to note that while <strong> <em>void*</em> </strong> can be used to build generic pointers, void itself cannot be declared as a variable type.</p> <p>Here is a sample of code that shows how to utilize void in various situations:</p> <pre> #include // Function with void return type void printHello() { printf(&apos;Hello, world!
&apos;); } // Function with void parameter void processInput(void) { printf(&apos;Processing input...
&apos;); } int main() { // Calling a void function printHello(); // Calling a function with void parameter processInput(); // Using a void pointer int number = 10; void* dataPtr = &amp;number; printf(&apos;Value of number: %d
&apos;, *(int*)dataPtr); return 0; } </pre> <p> <strong>Output:</strong> </p> <pre> Hello, world! Processing input... Value of number: 10 </pre> <h2>Conclusion:</h2> <p>As a result, <strong> <em>data types</em> </strong> are essential in the C programming language because they define the kinds of information that variables can hold. They provide the data&apos;s size and format, enabling the compiler to allot memory and carry out the necessary actions. Data types supported by C include <strong> <em>void, enumeration, derived</em> </strong> , and <strong> <em>basic types</em> </strong> . In addition to floating-point types like <strong> <em>float</em> </strong> and <strong> <em>double</em> </strong> , basic data types in C also include integer-based kinds like <strong> <em>int, char</em> </strong> , and <strong> <em>short</em> </strong> . These forms can be <strong> <em>signed</em> </strong> or <strong> <em>unsigned</em> </strong> , and they fluctuate in size and range. To create dependable and efficient code, it is crucial to comprehend the memory size and scope of these types.</p> <p>A few examples of <strong> <em>derived data types</em> </strong> are <strong> <em>unions, pointers, structures</em> </strong> , and <strong> <em>arrays</em> </strong> . Multiple elements of the same kind can be stored together in contiguous memory due to arrays. <strong> <em>Pointers</em> </strong> keep track of memory addresses, allowing for fast data structure operations and dynamic memory allocation. While <strong> <em>unions</em> </strong> allow numerous variables to share the same memory space, structures group relevant variables together.</p> <p> <strong> <em>Code</em> </strong> becomes more legible and maintainable when named constants are defined using enumeration data types. <strong> <em>Enumerations</em> </strong> give named constants integer values to enable the meaningful representation of related data. The void data type indicates the lack of a particular type. It is used as a return type for both <strong> <em>functions</em> </strong> and <strong> <em>function parameters</em> </strong> that don&apos;t take any arguments and don&apos;t return a value. The <strong> <em>void* pointer</em> </strong> also functions as a general pointer that can <strong> <em>store addresses</em> </strong> of various types.</p> <p>C programming requires a solid understanding of <strong> <em>data types</em> </strong> . Programmers can ensure adequate memory allocation, avoid <strong> <em>data overflow</em> </strong> or <strong> <em>truncation</em> </strong> , and enhance the readability and maintainability of their code by selecting the right <strong> <em>data type</em> </strong> . C programmers may create <strong> <em>effective, dependable</em> </strong> , and well-structured code that satisfies the requirements of their applications by having a firm understanding of data types.</p> <hr></5;>

Zeiger:

A Zeiger ist ein abgeleiteter Datentyp, der die Speicheradresse eines anderen Datentyps verfolgt. Wenn ein Zeiger erklärt wird, die Datentyp es bezieht sich auf ist zuerst angegeben , und dann die Variablennamen geht voran ein Sternchen (*) .

Sie können einen falschen Zugriff haben und den Wert einer Variablen mithilfe von Zeigern ändern, indem Sie die Speicheradresse der Variablen angeben. Hinweise werden häufig verwendet in Aufgaben wie zum Beispiel Funktionszeiger, Datenstrukturen , Und dynamische Speicherzuweisung .

Hier ist ein Beispiel für die Deklaration und Verwendung eines Zeigers:

 #include int main() { int num = 42; // An integer variable int *ptr; // Declares a pointer to an integer ptr = # // Assigns the address of 'num' to the pointer // Accessing the value of 'num' using the pointer printf('Value of num: %d
', *ptr); return 0; } 

Ausgabe:

 Value of num: 42 

Struktur:

Eine Struktur ist ein abgeleiteter Datentyp, der die Erstellung zusammengesetzter Datentypen ermöglicht, indem er die Gruppierung vieler Datentypen unter einem einzigen Namen ermöglicht. Es gibt Ihnen die Möglichkeit, Ihre eigenen einzigartigen Datenstrukturen zu erstellen, indem Sie Variablen verschiedener Art zusammenführen.

Huffman-Codierungscode

1. Die Mitglieder oder Felder einer Struktur werden verwendet, um auf jede darin enthaltene Variable zu verweisen.
2. Jeder Datentyp, einschließlich unterschiedlicher Strukturen, kann Mitglied einer Struktur sein.
3. Auf die Mitglieder einer Struktur kann mit dem Punktoperator (.) zugegriffen werden.

Eine Deklaration und Verwendung einer Struktur wird hier demonstriert:

 #include #include // Define a structure representing a person struct Person { char name[50]; int age; float height; }; int main() { // Declare a variable of type struct Person struct Person person1; // Assign values to the structure members strcpy(person1.name, 'John Doe'); person1.age = 30; person1.height = 1.8; // Accessing the structure members printf('Name: %s
', person1.name); printf('Age: %d
', person1.age); printf('Height: %.2f
', person1.height); return 0; } 

Ausgabe:

 Name: John Doe Age: 30 Height: 1.80 

Union:

Ein abgeleiteter Datentyp namens a Union ermöglicht es Ihnen, verschiedene Datentypen an derselben Speicheradresse zu speichern. Im Gegensatz zu Strukturen, bei denen jedes Mitglied über einen separaten Speicherplatz verfügt, teilen sich die Mitglieder einer Union alle einen einzigen Speicherplatz. Ein Wert kann zu einem bestimmten Zeitpunkt nur von einem Mitglied einer Gewerkschaft gehalten werden. Wenn Sie viele Datentypen austauschbar darstellen müssen, sind Gewerkschaften praktisch. Wie bei Strukturen können Sie über die auf die Mitglieder einer Union zugreifen Punkt (.) Operator.

Hier ist ein Beispiel für die Deklaration und Verwendung einer Union:

 #include // Define a union representing a numeric value union NumericValue { int intValue; float floatValue; char stringValue[20]; }; int main() { // Declare a variable of type union NumericValue union NumericValue value; // Assign a value to the union value.intValue = 42; // Accessing the union members printf('Integer Value: %d
', value.intValue); // Assigning a different value to the union value.floatValue = 3.14; // Accessing the union members printf('Float Value: %.2f
', value.floatValue); return 0; } 

Ausgabe:

 Integer Value: 42 Float Value: 3.14 

Aufzählungsdatentyp

Eine Menge benannter Konstanten oder Aufzähler die eine Sammlung verbundener Werte darstellen, können in C mithilfe von definiert werden Aufzählungsdatentyp (enum). Aufzählungen Geben Sie Ihnen die Möglichkeit, einer Gruppe ganzzahliger Werte sinnvolle Namen zu geben, wodurch Ihr Code einfacher zu lesen und zu warten ist.

für Loop-Bash

Hier ist ein Beispiel für die Definition und Verwendung einer Aufzählung in C:

 #include // Define an enumeration for days of the week enum DaysOfWeek { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }; int main() { // Declare a variable of type enum DaysOfWeek enum DaysOfWeek today; // Assign a value from the enumeration today = Wednesday; // Accessing the enumeration value printf('Today is %d
', today); return 0; } 

Ausgabe:

 Today is 2 

Ungültiger Datentyp

Der void-Datentyp wird in der Sprache C verwendet, um das Fehlen eines bestimmten Typs anzuzeigen. Funktionsrückgabetypen, Funktionsparameter , Und Hinweise Es gibt drei Situationen, in denen es häufig verwendet wird.

Funktionsrückgabetyp:

A void-Rückgabetyp Funktion erzeugt keinen Wert. A Leere Funktion Führt eine Aufgabe oder Aktion aus und endet, anstatt einen Wert zurückzugeben.

Beispiel:

 void printHello() { printf('Hello, world!
'); } 

Funktionsparameter:

Der Parameter ungültig kann verwendet werden, um anzuzeigen, dass eine Funktion keine Argumente akzeptiert.

Beispiel:

 void processInput(void) { /* Function logic */ } 

Hinweise:

Jede Adresse kann in einem Zeiger vom Typ gespeichert werden Leere* , was es zu einem universellen Zeiger macht. Es bietet eine Methode zum Arbeiten mit Zeigern auf mehrdeutige oder atypische Typen.

Beispiel:

 void* dataPtr; 

Der void-Datentyp ist hilfreich beim Definieren von Funktionen, die keine Argumente akzeptieren, wenn Sie mit generischen Zeigern arbeiten oder wenn Sie signalisieren möchten, dass eine Funktion keinen Wert zurückgibt. Es ist wichtig, dies zu beachten Leere* kann zum Erstellen generischer Zeiger verwendet werden, void selbst kann nicht als Variablentyp deklariert werden.

Hier ist ein Beispielcode, der zeigt, wie void in verschiedenen Situationen verwendet wird:

Java-Grundlagen

 #include // Function with void return type void printHello() { printf('Hello, world!
'); } // Function with void parameter void processInput(void) { printf('Processing input...
'); } int main() { // Calling a void function printHello(); // Calling a function with void parameter processInput(); // Using a void pointer int number = 10; void* dataPtr = &number; printf('Value of number: %d
', *(int*)dataPtr); return 0; } 

Ausgabe:

 Hello, world! Processing input... Value of number: 10 

Abschluss:

Infolge, Datentypen sind in der Programmiersprache C von wesentlicher Bedeutung, da sie die Arten von Informationen definieren, die Variablen enthalten können. Sie geben die Größe und das Format der Daten an und ermöglichen es dem Compiler, Speicher zuzuweisen und die erforderlichen Aktionen auszuführen. Zu den von C unterstützten Datentypen gehören: nichtig, Aufzählung, abgeleitet , Und Grundtypen . Zusätzlich zu Gleitkommatypen wie schweben Und doppelt Zu den grundlegenden Datentypen in C gehören auch ganzzahlbasierte Arten wie int, char , Und kurz . Diese Formen können sein unterzeichnet oder ohne Vorzeichen , und sie schwanken in Größe und Reichweite. Um zuverlässigen und effizienten Code zu erstellen, ist es wichtig, die Speichergröße und den Speicherumfang dieser Typen zu verstehen.

Ein paar Beispiele von abgeleitete Datentypen Sind Gewerkschaften, Zeiger, Strukturen , Und Arrays . Aufgrund von Arrays können mehrere Elemente derselben Art zusammen in einem zusammenhängenden Speicher gespeichert werden. Hinweise Behalten Sie den Überblick über Speicheradressen und ermöglichen Sie so schnelle Datenstrukturoperationen und dynamische Speicherzuweisung. Während Gewerkschaften Ermöglichen Sie, dass sich zahlreiche Variablen den gleichen Speicherplatz teilen. Strukturen gruppieren relevante Variablen.

Code wird besser lesbar und wartbar, wenn benannte Konstanten mithilfe von Aufzählungsdatentypen definiert werden. Aufzählungen Geben Sie benannten Konstanten ganzzahlige Werte, um eine sinnvolle Darstellung verwandter Daten zu ermöglichen. Der ungültige Datentyp weist auf das Fehlen eines bestimmten Typs hin. Es wird für beide als Rückgabetyp verwendet Funktionen Und Funktionsparameter die keine Argumente entgegennehmen und keinen Wert zurückgeben. Der void* Zeiger fungiert auch als allgemeiner Zeiger, der dies kann Ladenadressen verschiedener Art.

C-Programmierung erfordert ein solides Verständnis von Datentypen . Programmierer können eine angemessene Speicherzuteilung sicherstellen und vermeiden Datenüberlauf oder Kürzung , und verbessern Sie die Lesbarkeit und Wartbarkeit ihres Codes, indem Sie das Richtige auswählen Datentyp . C-Programmierer können erstellen effektiv, zuverlässig und gut strukturierter Code, der die Anforderungen ihrer Anwendungen erfüllt, indem er über ein fundiertes Verständnis der Datentypen verfügt.