Tietotyyppi määrittää datatyypin, jonka muuttuja voi tallentaa, kuten kokonaisluku, kelluva, merkki jne.

C-kielellä on seuraavat tietotyypit.

Perustietotyypit

Perustietotyypit ovat kokonaislukupohjaisia ​​ja liukulukupohjaisia. C-kieli tukee sekä etumerkittömiä että etumerkittömiä literaaleja.

Perustietotyyppien muistikoko voi vaihdella 32- tai 64-bittisen käyttöjärjestelmän mukaan.

mysql ainutlaatuinen avain

Katsotaanpa perustietotyypit. Sen koko on annettu 32-bittisen arkkitehtuurin mukaan .

Int:

Kokonaisluvut ovat kokonaislukuja ilman murto- tai desimaaliosia, ja int tietotyyppi käytetään edustamaan niitä.

Sitä käytetään usein muuttujiin, jotka sisältävät arvot , kuten luvut, indeksit , tai muita numeerisia numeroita. The int tietotyyppi voivat edustaa molempia positiivinen ja negatiivisia lukuja koska se on oletuksena allekirjoitettu.

An int kestää 4 tavua muistia useimmissa laitteissa, jolloin se voi tallentaa arvoja noin -2 miljardin ja +2 miljardin välillä.

Hiiltyä:

Yksittäisiä merkkejä edustaa char-tietotyyppi . Yleensä käytetään pitämään ASCII tai UTF-8-koodausmallin merkit , kuten kirjaimia, numeroita, symboleja , tai pilkkuja . On 256 merkkiä joka voidaan esittää yhdellä merkillä, joka vie yhden tavun muistia. Hahmot kuten 'A', 'b', '5', tai '$' ovat yksittäisten lainausmerkkien sisällä.

Kellua:

Jos haluat esittää kokonaislukuja, käytä kelluva tietotyyppi . Kelluvia lukuja voidaan käyttää esittämään murto-osia tai lukuja desimaalilla.

The kelluva tyyppi käytetään yleensä muuttujille, jotka vaativat erittäin hyvää tarkkuutta, mutta eivät välttämättä ole kovin tarkkoja. Se voi tallentaa arvoja noin tarkkuudella 6 desimaalin tarkkuudella ja valikoima noin 3,4 x 1038 sisään 4 tavua muistista.

Kaksinkertainen:

Käytä edustamiseen kahta tietotyyppiä kaksi kelluvaa kokonaislukua . Kun tarvitaan lisätarkkuutta, kuten tieteellisissä laskelmissa tai taloudellisissa sovelluksissa, se tarjoaa paremman tarkkuuden kuin kelluva.

Kaksinkertainen tyyppi , joka käyttää 8 tavua muistia ja sen tarkkuus on noin 15 desimaalin tarkkuudella, tuottaa suurempia arvoja . C käsittelee liukulukuja oletusarvoisesti tuplalukuina, jos nimenomaista tyyppiä ei ole annettu.

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

Yllä olevassa esimerkissä ilmoitamme neljä muuttujaa: an int muuttuja henkilön iän mukaan, a char muuttuja opiskelijan arvosanalle, a kelluva muuttuja lämpötilalukemaa varten ja kaksi muuttujaa numero pi.

java avoin tiedosto

Johtettu tietotyyppi

Perustietotyyppien lisäksi C tukee myös johdetut tietotyypit, mukaan lukien taulukot, osoittimet, rakenteet, ja ammattiliitot . Nämä tietotyypit antavat ohjelmoijille mahdollisuuden käsitellä heterogeenisiä tietoja, muokata suoraan muistia ja rakentaa monimutkaisia ​​tietorakenteita.

Taulukko:

An array, johdettu tietotyyppi , voit tallentaa sarjan kiinteän kokoisia elementtejä samaa tyyppiä. Se tarjoaa mekanismin useiden saman datan kohteiden yhdistämiseen samalla nimellä.

Indeksiä käytetään taulukon elementtien käsiksi a.:lla 0 indeksi ensimmäistä sisääntuloa varten. Taulukon koko on kiinteä ilmoitushetkellä, eikä sitä voi muuttaa ohjelman suorittamisen aikana. Matriisikomponentit sijoitetaan vierekkäisille muistialueille.

Tässä on esimerkki taulukon ilmoittamisesta ja käytöstä:

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

Osoitin:

A osoitin on johdettu tietotyyppi, joka pitää kirjaa toisen tietotyypin muistiosoitteesta. Kun osoitin on julistettu, tietotyyppi se viittaa on totesi ensin , ja sitten muuttujan nimi edeltää tähti (*) .

Voit käyttää väärin ja muuttaa muuttujan arvoa osoittimien avulla määrittämällä muuttujan muistiosoitteen. Osoittimet käytetään yleisesti tehtäviä kuten funktioosoittimet, tietorakenteet , ja dynaaminen muistin varaus .

Tässä on esimerkki osoittimen ilmoittamisesta ja käyttämisestä:

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

Lähtö:

 Value of num: 42 

Rakenne:

Rakenne on johdettu tietotyyppi, joka mahdollistaa yhdistelmätietotyyppien luomisen sallimalla useiden tietotyyppien ryhmittelyn yhden nimen alle. Se antaa sinulle mahdollisuuden luoda omia ainutlaatuisia tietorakenteita yhdistämällä erityyppisiä muuttujia.

lausunnon kattavuus

1. Rakenteen jäseniä tai kenttiä käytetään viittaamaan jokaiseen muuttujaan siinä.
2. Mikä tahansa tietotyyppi, mukaan lukien erilaiset rakenteet, voi olla rakenteen jäsen.
3. Rakenteen jäseniin pääsee käsiksi piste (.) -operaattorilla.

Selvitys ja rakenteen käyttö on esitetty tässä:

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

Lähtö:

 Name: John Doe Age: 30 Height: 1.80 

Liitto:

Johdettu tietotyyppi nimeltä a liitto mahdollistaa erilaisten tietotyyppien tallentamisen samaan muistiosoitteeseen. Toisin kuin rakenteissa, joissa jokaisella jäsenellä on erillinen muistitila, liiton jäsenet jakavat kaikki yhden muistitilan. Arvo voi olla vain yhdellä ammattiliiton jäsenellä kullakin hetkellä. Kun sinun on esitettävä useita tietotyyppejä vaihtokelpoisesti, liitot ovat hyödyllisiä. Kuten rakenteet, voit käyttää liiton jäseniä käyttämällä piste (.) operaattori.

Tässä on esimerkki liitosta, joka julistetaan ja sitä käytetään:

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

Lähtö:

 Integer Value: 42 Float Value: 3.14 

Luettelotietotyyppi

Joukko nimettyjä vakioita tai luetteloijia jotka edustavat kokoelmaa yhdistettyjä arvoja voidaan määrittää C:ssä käyttämällä luettelointitietotyyppi (enum). Luettelot antaa sinulle keinot antaa järkeviä nimiä integraaliarvojen ryhmälle, mikä tekee koodistasi helpompi lukea ja ylläpitää.

Tässä on esimerkki luettelon määrittämisestä ja käytöstä C:ssä:

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

Lähtö:

 Today is 2 

Void Data Type

The tyhjä tietotyyppi C-kielessä käytetään ilmaisemaan tietyn tyypin puuttumista. Funktioiden palautustyypit, funktion parametrit , ja osoittimia on kolme tilannetta, joissa sitä käytetään usein.

Toiminnon palautustyyppi:

A mitätön palautustyyppi funktio ei tuota arvoa. A tyhjä toiminto suorittaa tehtävän tai toiminnon ja lopettaa arvon palauttamisen sijaan.

Esimerkki:

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

Toimintoparametrit:

The parametri mitätön voidaan käyttää osoittamaan, että funktio ei hyväksy argumentteja.

Esimerkki:

nukkainen loki

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

Osoittimet:

Mikä tahansa osoite voidaan tallentaa tyyppiseen osoittimeen tyhjä* , mikä tekee siitä yleisen osoittimen. Se tarjoaa menetelmän työskennellä moniselitteisiin tai epätyypillisiin tyyppeihin viittaavien osoittimien kanssa.

Esimerkki:

 void* dataPtr; 

The tyhjä tietotyyppi on hyödyllinen sellaisten funktioiden määrittämisessä, jotka eivät hyväksy argumentteja, kun työskentelet yleisten osoittimien kanssa tai kun haluat ilmoittaa, että funktio ei palauta arvoa. On tärkeää huomata, että samalla tyhjä* voidaan käyttää yleisten osoittimien rakentamiseen, itse void ei voida ilmoittaa muuttujatyypiksi.

Tässä on esimerkki koodista, joka näyttää, kuinka tyhjyyttä voidaan käyttää eri tilanteissa:

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

Lähtö:

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

Johtopäätös:

Tuloksena, tietotyypit ovat tärkeitä C-ohjelmointikielessä, koska ne määrittelevät, millaista tietoa muuttujat voivat sisältää. Ne tarjoavat tiedon koon ja muodon, jolloin kääntäjä voi varata muistia ja suorittaa tarvittavat toimenpiteet. C:n tukemat tietotyypit sisältävät mitätön, luettelointi, johdettu , ja perustyypit . Liukulukutyyppien lisäksi, kuten kellua ja kaksinkertainen , C:n perustietotyypit sisältävät myös kokonaislukupohjaisia ​​tyyppejä, kuten int, char , ja lyhyt . Nämä lomakkeet voivat olla allekirjoitettu tai allekirjoittamaton , ja ne vaihtelevat kooltaan ja valikoimaltaan. Luotettavan ja tehokkaan koodin luomiseksi on ratkaisevan tärkeää ymmärtää näiden tyyppien muistin koko ja laajuus.

Muutama esimerkki johdetut tietotyypit ovat liitot, osoittimet, rakenteet , ja taulukoita . Useita samanlaisia ​​elementtejä voidaan tallentaa vierekkäiseen muistiin taulukoiden vuoksi. Osoittimet seurata muistiosoitteita, mikä mahdollistaa nopeat tietorakennetoiminnot ja dynaamisen muistin allokoinnin. Sillä aikaa ammattiliitot sallia useiden muuttujien jakaa saman muistitilan, rakenteet ryhmittelevät merkitykselliset muuttujat yhteen.

Koodi tulee luettavammaksi ja ylläpidettävämmäksi, kun nimetyt vakiot määritellään numeraatiotietotyypeillä. Luettelot anna nimetyt vakiot kokonaislukuarvot mahdollistaaksesi toisiinsa liittyvien tietojen merkityksellisen esittämisen. Tyhjä tietotyyppi ilmaisee tietyn tyypin puuttumisen. Sitä käytetään palautustyyppinä molemmille toimintoja ja toimintoparametreja jotka eivät ota argumentteja eivätkä palauta arvoa. The tyhjä* osoitin toimii myös yleisenä osoittimena, joka voi myymälöiden osoitteet eri tyyppisiä.

C-ohjelmointi vaatii vankkaa ymmärrystä tietotyypit . Ohjelmoijat voivat varmistaa riittävän muistin varauksen, välttää tietojen ylivuoto tai katkaisu ja parantaa niiden koodin luettavuutta ja ylläpidettävyyttä valitsemalla oikea tietotyyppi . C-ohjelmoijat voivat luoda tehokas, luotettava , ja hyvin jäsenneltyä koodia, joka täyttää heidän sovellustensa vaatimukset ymmärtämällä tietotyypit.

tcp vs udp