Een gegevenstype specificeert het type gegevens dat een variabele kan opslaan, zoals geheel getal, zwevend, teken, enz.

Er zijn de volgende gegevenstypen in C-taal.

Basisgegevenstypen

De basisgegevenstypen zijn gebaseerd op gehele getallen en op drijvende komma's. C-taal ondersteunt zowel ondertekende als niet-ondertekende letterlijke waarden.

De geheugengrootte van de basisgegevenstypen kan veranderen afhankelijk van het 32- of 64-bits besturingssysteem.

rhel versus centos

Laten we de basisgegevenstypen bekijken. De grootte ervan is gegeven volgens 32-bits architectuur .

Int.:

gehele getallen zijn hele getallen zonder breuken of decimale delen, en de int-gegevenstype wordt gebruikt om hen te vertegenwoordigen.

Het wordt vaak toegepast op variabelen die omvatten waarden , zoals tellingen, indexen of andere numerieke getallen. De int-gegevenstype kan beide vertegenwoordigen positief En negatieve getallen omdat het standaard ondertekend is.

Een int neemt 4 bytes geheugen op de meeste apparaten, waardoor waarden tussen ongeveer -2 miljard en +2 miljard kunnen worden opgeslagen.

Char:

Individuele karakters worden vertegenwoordigd door de char-gegevenstype . Meestal gebruikt om vast te houden ASCII of Tekens voor UTF-8-coderingsschema , zoals letters, cijfers, symbolen , of komma's . Er zijn 256 tekens dat kan worden weergegeven door een enkele char, die één byte geheugen in beslag neemt. Karakters zoals 'A', 'b', '5', of '$' staan ​​tussen enkele aanhalingstekens.

Vlot:

Om gehele getallen weer te geven, gebruik je de zwevend gegevenstype . Zwevende getallen kunnen worden gebruikt om breukeenheden of getallen met decimalen weer te geven.

De vlotter type wordt meestal gebruikt voor variabelen die een zeer goede precisie vereisen, maar mogelijk niet erg nauwkeurig zijn. Het kan waarden opslaan met een nauwkeurigheid van ongeveer 6 decimalen en een bereik van ongeveer 3,4 x 1038 in 4 bytes van geheugen.

Dubbele:

Gebruik twee gegevenstypen om weer te geven twee zwevende gehele getallen . Wanneer extra precisie nodig is, zoals bij wetenschappelijke berekeningen of financiële toepassingen, biedt het een grotere nauwkeurigheid dan float.

teken naar int in Java

Dubbele soort , die gebruikt 8 bytes geheugen en heeft een nauwkeurigheid van ongeveer 15 decimalen, levert grotere waarden op . C behandelt getallen met drijvende komma standaard als verdubbelingen als er geen expliciet type wordt opgegeven.

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

In het bovenstaande voorbeeld declareren we vier variabelen: int-variabele voor de leeftijd van de persoon, a char variabele voor het cijfer van de student, a zwevende variabele voor de temperatuurmeting, en twee variabelen voor de nummer pi.

Afgeleid gegevenstype

Naast de fundamentele gegevenstypen ondersteunt C ook afgeleide gegevenstypen, inbegrepen arrays, pointers, structuren, En vakbonden . Deze datatypen geven programmeurs de mogelijkheid om heterogene data te verwerken, het geheugen direct aan te passen en ingewikkelde datastructuren te bouwen.

Array:

Een array, een afgeleid gegevenstype , kunt u een reeks opslaan elementen met vaste afmetingen van hetzelfde type. Het biedt een mechanisme voor het samenvoegen van meerdere doelen van dezelfde gegevens onder dezelfde naam.

De index wordt gebruikt om toegang te krijgen tot de elementen van de array, met a 0 index voor de eerste inzending. De grootte van de array ligt vast op het moment van declaratie en kan niet worden gewijzigd tijdens de uitvoering van het programma. De arraycomponenten worden in aangrenzende geheugengebieden geplaatst.

Hier is een voorbeeld van het declareren en gebruiken van een array:

 #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;>

Wijzer:

A wijzer is een afgeleid gegevenstype dat het geheugenadres van een ander gegevenstype bijhoudt. Wanneer een wijzer wordt verklaard, de data type het verwijst naar is als eerste vermeld , en dan de variabele naam wordt voorafgegaan door een asterisk (*) .

U kunt onjuiste toegang krijgen en de waarde van een variabele wijzigen met behulp van pointers door het geheugenadres van de variabele op te geven. Wijzers worden vaak gebruikt taken zoals functieaanwijzers, datastructuren , En dynamische geheugentoewijzing .

Hier is een voorbeeld van het declareren en gebruiken van een pointer:

 #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; } 

Uitgang:

 Value of num: 42 

Structuur:

Een structuur is een afgeleid gegevenstype dat het creëren van samengestelde gegevenstypen mogelijk maakt door het groeperen van vele gegevenstypen onder één enkele naam mogelijk te maken. Het geeft u de mogelijkheid om uw eigen unieke datastructuren te creëren door variabelen van verschillende soorten samen te voegen.

Linux hernoemt map

1. De leden of velden van een structuur worden gebruikt om naar elke variabele daarin te verwijzen.
2. Elk gegevenstype, inclusief verschillende structuren, kan lid zijn van een structuur.
3. De leden van een structuur kunnen worden benaderd met behulp van de puntoperator (.).

Een verklaring en gebruik van een structuur wordt hier gedemonstreerd:

 #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; } 

Uitgang:

 Name: John Doe Age: 30 Height: 1.80 

Unie:

Een afgeleid gegevenstype genaamd a unie stelt u in staat verschillende gegevenstypen op hetzelfde geheugenadres op te slaan. In tegenstelling tot structuren waarbij elk lid een aparte geheugenruimte heeft, delen de leden van een vakbond allemaal één enkele geheugenruimte. Een waarde kan op elk moment slechts door één lid van een vakbond worden vastgehouden. Wanneer u veel gegevenstypen door elkaar moet vertegenwoordigen, zijn vakbonden handig. Net als bij structuren kun je toegang krijgen tot de leden van een vakbond door gebruik te maken van de punt (.) exploitant.

Hier is een voorbeeld van een vakbond die wordt aangegeven en gebruikt:

 #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; } 

Uitgang:

 Integer Value: 42 Float Value: 3.14 

Opsommingsgegevenstype

Een reeks benoemde constanten of tellers die een verzameling verbonden waarden vertegenwoordigen, kunnen in C worden gedefinieerd met behulp van de opsommingsgegevenstype (enum). Opsommingen geven u de mogelijkheid om namen te geven die zinvol zijn voor een groep integrale waarden, waardoor uw code gemakkelijker te lezen en te onderhouden is.

Hier is een voorbeeld van hoe u een opsomming in C definieert en gebruikt:

 #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; } 

Uitgang:

 Today is 2 

Gegevenstype ongeldig

De ongeldig gegevenstype in de C-taal wordt gebruikt om het ontbreken van een bepaald type aan te duiden. Functieretourtypen, functieparameters , En aanwijzingen Er zijn drie situaties waarin het vaak wordt gebruikt.

Functie retourtype:

A retourneringstype ongeldig functie produceert geen waarde. A leegte functie voert een taak of actie uit en eindigt in plaats van een waarde terug te geven.

Voorbeeld:

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

Functieparameters:

De parameter leeg kan worden gebruikt om aan te geven dat een functie geen argumenten accepteert.

Rihanna leeftijd

Voorbeeld:

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

Aanwijzingen:

Elk adres kan worden opgeslagen in een pointer van het type leegte* , waardoor het een universele aanwijzer is. Het biedt een methode om te werken met verwijzingen naar dubbelzinnige of atypische typen.

Voorbeeld:

 void* dataPtr; 

De ongeldig gegevenstype is handig voor het definiëren van functies die geen argumenten accepteren als u met generieke verwijzingen werkt of als u wilt aangeven dat een functie geen waarde retourneert. Het is belangrijk om op te merken dat terwijl leegte* kan worden gebruikt om generieke verwijzingen te bouwen, maar void zelf kan niet als een variabel type worden gedeclareerd.

Hier is een codevoorbeeld dat laat zien hoe u void in verschillende situaties kunt gebruiken:

 #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; } 

Uitgang:

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

Conclusie:

Als gevolg, gegevenstypen zijn essentieel in de programmeertaal C omdat ze de soorten informatie definiëren die variabelen kunnen bevatten. Ze geven de grootte en het formaat van de gegevens weer, waardoor de compiler geheugen kan toewijzen en de nodige acties kan uitvoeren. Gegevenstypen die door C worden ondersteund, zijn onder meer leegte, opsomming, afgeleid , En basistypen . Naast drijvende-kommatypen zoals vlot En dubbele , omvatten basisgegevenstypen in C ook op gehele getallen gebaseerde soorten zoals int, kar , En kort . Deze vormen kunnen zijn ondertekend of niet ondertekend , en ze fluctueren in omvang en bereik. Om betrouwbare en efficiënte code te creëren, is het van cruciaal belang om de geheugengrootte en reikwijdte van dit soort code te begrijpen.

Een paar voorbeelden van afgeleide gegevenstypen Zijn vakbonden, aanwijzingen, structuren , En arrays . Dankzij arrays kunnen meerdere elementen van dezelfde soort samen in aaneengesloten geheugen worden opgeslagen. Wijzers houd geheugenadressen bij, waardoor snelle gegevensstructuurbewerkingen en dynamische geheugentoewijzing mogelijk zijn. Terwijl vakbonden zorgen ervoor dat talloze variabelen dezelfde geheugenruimte kunnen delen, structuren groeperen relevante variabelen samen.

Linux$home

Code wordt beter leesbaar en onderhoudbaar wanneer benoemde constanten worden gedefinieerd met behulp van opsommingsgegevenstypen. Opsommingen geef benoemde constanten gehele waarden om de betekenisvolle representatie van gerelateerde gegevens mogelijk te maken. Het void-gegevenstype geeft het ontbreken van een bepaald type aan. Het wordt voor beide gebruikt als retourtype functies En functieparameters die geen argumenten gebruiken en geen waarde retourneren. De ongeldige* aanwijzer functioneert ook als een algemene aanwijzer die dat wel kan winkeladressen van verschillende soorten.

C-programmeren vereist een goed begrip van gegevenstypen . Programmeurs kunnen zorgen voor voldoende geheugentoewijzing, vermijden gegevensoverloop of inkorting , en verbeter de leesbaarheid en onderhoudbaarheid van hun code door het juiste te selecteren data type . C-programmeurs kunnen creëren effectief, betrouwbaar , en goed gestructureerde code die voldoet aan de vereisten van hun toepassingen door een goed begrip van gegevenstypen te hebben.