Az adattípus meghatározza, hogy egy változó milyen adattípust tárolhat, például egész, lebegő, karakter stb.

A következő adattípusok léteznek C nyelvben.

Alapvető adattípusok

Az alapvető adattípusok egész és lebegőpontos alapúak. A C nyelv támogatja az előjeles és előjel nélküli literálokat is.

Az alap adattípusok memóriamérete a 32 vagy 64 bites operációs rendszertől függően változhat.

arraylist.sort

Lássuk az alapvető adattípusokat. A mérete adott 32 bites architektúra szerint .

Int:

Egész számok egész számok tört vagy tizedes rész nélkül, és a int adattípus ábrázolására használják.

Gyakran alkalmazzák olyan változókra, amelyek tartalmazzák értékeket , mint például számok, indexek , vagy más numerikus számok. A int adattípus mindkettőt képviselheti pozitív és negatív számok mert alapból alá van írva.

An int felvesz 4 bájt memóriát a legtöbb eszközön, így körülbelül -2 milliárd és +2 milliárd közötti értékeket tárolhat.

Char:

Az egyes karaktereket a char adattípus . Általában tartásra használják ASCII vagy UTF-8 kódolási séma karakterei , mint például betűk, számok, szimbólumok , vagy vesszők . Vannak 256 karakter amely egyetlen karakterrel ábrázolható, amely egy bájt memóriát foglal el. Olyan karakterek, mint pl 'A', 'b', '5', vagy '$' idézőjelek között vannak.

Úszó:

Egész számok ábrázolásához használja a lebegő adattípus . A lebegő számok a tört egységek vagy a tizedesjegyű számok ábrázolására használhatók.

A úszó típusú általában olyan változókhoz használatos, amelyek nagyon jó pontosságot igényelnek, de előfordulhat, hogy nem túl pontosak. Kb. pontossággal képes értékeket tárolni 6 tizedesjegy és kb 3,4 x 1038 ban ben 4 bájt az emlékezés.

Kettős:

Használjon két adattípust az ábrázoláshoz két lebegő egész szám . Ha további pontosságra van szükség, például tudományos számításoknál vagy pénzügyi alkalmazásoknál, nagyobb pontosságot biztosít az úszóhoz képest.

Dupla típus , amely használ 8 bájt memória és kb 15 tizedesjegy, nagyobb értékeket ad . A C a lebegőpontos számokat alapértelmezés szerint dupláként kezeli, ha nincs megadva kifejezett típus.

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

A fenti példában négy változót deklarálunk: an int változó a személy életkorára, a char változó a tanuló évfolyamára, a float változó a hőmérséklet leolvasásához, és két változó a szám pi.

Származtatott adattípus

Az alapvető adattípusokon túl a C is támogatja származtatott adattípusok, beleértve tömbök, mutatók, struktúrák, és szakszervezetek . Ezek az adattípusok lehetővé teszik a programozók számára, hogy heterogén adatokat kezeljenek, közvetlenül módosítsák a memóriát és bonyolult adatstruktúrákat építsenek fel.

mi az android easter egg

Sor:

An tömb, egy származtatott adattípus , lehetővé teszi a sorozat tárolását fix méretű elemek azonos típusú. Ez egy olyan mechanizmust biztosít, amely lehetővé teszi több, ugyanazon adatból származó cél azonos néven történő összekapcsolását.

Az index a tömb elemeinek elérésére szolgál, a 0 index az első bejegyzéshez. A tömb mérete a deklaráció időpontjában rögzített, és a program végrehajtása során nem módosítható. A tömb komponensei a szomszédos memóriaterületekbe kerülnek.

Íme egy példa egy tömb deklarálására és használatára:

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

Mutató:

A mutató egy származtatott adattípus, amely nyomon követi egy másik adattípus memóriacímét. Amikor a mutató kijelentik, a adattípus arra utal nyilatkozta először , majd a változó neve előzi meg egy csillag (*) .

Helytelen hozzáférést kaphat, és mutatókkal módosíthatja a változó értékét, ha megadja a változó memóriacímét. Mutatók általában használják feladatokat mint például függvénymutatók, adatstruktúrák , és dinamikus memóriafoglalás .

Íme egy példa a mutató deklarálására és használatára:

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

Kimenet:

 Value of num: 42 

Szerkezet:

A struktúra egy származtatott adattípus, amely lehetővé teszi összetett adattípusok létrehozását azáltal, hogy lehetővé teszi számos adattípus egyetlen név alatti csoportosítását. Lehetővé teszi saját egyedi adatszerkezetek létrehozását különböző típusú változók összeolvasztásával.

blokkolt számok

1. A struktúra tagjai vagy mezői az egyes változókra hivatkoznak.
2. Bármilyen adattípus, beleértve a különböző struktúrákat is, lehet egy struktúra tagja.
3. A struktúra tagjai a pont (.) operátor segítségével érhetők el.

A nyilatkozatot és a szerkezet használatát itt mutatjuk be:

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

Kimenet:

 Name: John Doe Age: 30 Height: 1.80 

Unió:

Egy származtatott adattípus, az úgynevezett a unió lehetővé teszi különböző típusú adatok tárolását ugyanazon a memóriacímen. Ellentétben azokkal a struktúrákkal, ahol minden tagnak külön memóriaterülete van, a szakszervezet tagjai egyetlen memóriaterületen osztoznak. Egy értéket egy adott pillanatban csak egy szakszervezeti tag birtokolhat. Ha sok adattípust felcserélhetően kell ábrázolnia, a szakszervezetek jól jönnek. A struktúrákhoz hasonlóan a szakszervezet tagjait is elérheti a pont (.) operátor.

Íme egy példa a szakszervezet deklarálására és használatára:

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

Kimenet:

 Integer Value: 42 Float Value: 3.14 

Felsorolási adattípus

Megnevezett állandók halmaza ill összeírók amelyek összekapcsolt értékek gyűjteményét képviselik, a C-ben definiálhatók a felsorolás adattípusa (enum). Felsorolások lehetőséget ad arra, hogy értelmes neveket adjon az integrált értékek egy csoportjának, ami megkönnyíti a kód olvasását és karbantartását.

Íme egy példa a felsorolás meghatározására és használatára C-ben:

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

Kimenet:

 Today is 2 

Érvénytelen adattípus

A érvénytelen adattípus a C nyelvben egy adott típus hiányának jelölésére szolgál. A függvény visszatérési típusai, függvényparaméterek , és mutatók három olyan helyzet, amikor gyakran használják.

rdbms

Funkció visszatérési típusa:

A érvénytelen visszatérési típus függvény nem ad értéket. A üres funkció végrehajt egy feladatot vagy műveletet, és nem ad vissza értéket, hanem befejezi.

Példa:

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

Funkció paraméterei:

A paraméter érvénytelen használható annak jelzésére, hogy egy függvény nem fogad el argumentumokat.

Példa:

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

Mutatók:

Bármely cím tárolható egy típusú mutatóban üres* , így univerzális mutató. Módszert kínál a kétértelmű vagy atipikus típusokra mutató mutatókkal való munkavégzéshez.

Rekha színész

Példa:

 void* dataPtr; 

A érvénytelen adattípus hasznos olyan függvények meghatározásában, amelyek nem fogadnak el argumentumot, amikor általános mutatókkal dolgozik, vagy ha azt szeretné jelezni, hogy egy függvény nem ad vissza értéket. Fontos megjegyezni, hogy míg üres* általános mutatók készítésére használható, maga a void nem deklarálható változótípusként.

Íme egy példa a kódból, amely bemutatja, hogyan kell felhasználni az ürességet különböző helyzetekben:

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

Kimenet:

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

Következtetés:

Ennek eredményeként adattípusok nélkülözhetetlenek a C programozási nyelvben, mert meghatározzák, hogy a változók milyen információkat tartalmazhatnak. Megadják az adatok méretét és formátumát, lehetővé téve a fordító számára a memória lefoglalását és a szükséges műveletek végrehajtását. A C által támogatott adattípusok közé tartozik semmis, felsorolás, származtatott , és alaptípusok . A lebegőpontos típusok mellett, mint pl úszó és kettős , C-ben az alapadattípusok is tartalmaznak olyan egész számokat, mint pl int, char , és rövid . Ezek a formák lehetnek aláírva vagy aláírás nélküli , méretük és tartományuk pedig ingadozik. Megbízható és hatékony kód létrehozásához kulcsfontosságú az ilyen típusú memória méretének és hatókörének megértése.

Néhány példa arra származtatott adattípusok vannak szakszervezetek, mutatók, struktúrák , és tömbök . A tömbök miatt több azonos típusú elem együtt tárolható a szomszédos memóriában. Mutatók nyomon követheti a memóriacímeket, lehetővé téve a gyors adatszerkezeti műveleteket és a dinamikus memóriakiosztást. Míg szakszervezetek lehetővé teszi, hogy számos változó ugyanazon a memóriaterületen osztozzon, a struktúrák a releváns változókat csoportosítják.

Kód olvashatóbbá és karbantarthatóbbá válik, ha az elnevezett konstansokat felsorolási adattípusok segítségével határozzák meg. Felsorolások adjon megnevezett konstansoknak egész értékeket, hogy lehetővé tegye a kapcsolódó adatok értelmes ábrázolását. Az érvénytelen adattípus egy adott típus hiányát jelzi. Mindkettőnél visszatérési típusként használatos funkciókat és funkció paraméterei amelyek nem fogadnak el érveket és nem adnak vissza értéket. A érvénytelen* mutató általános mutatóként is funkcionál, amely képes üzletek címei különféle típusú.

A C programozás alapos ismerete szükséges adattípusok . A programozók biztosíthatják a megfelelő memóriafoglalást, elkerülhetik adattúlcsordulás vagy csonkítás , és javítják kódjuk olvashatóságát és karbantarthatóságát a megfelelő kiválasztásával adattípus . A C programozók létrehozhatnak hatékony, megbízható , és jól strukturált kód, amely megfelel az alkalmazásaik követelményeinek azáltal, hogy jól ismeri az adattípusokat.