Duomenų tipas nurodo duomenų, kuriuos kintamasis gali saugoti, tipą, pvz., sveikasis skaičius, slankusis skaičius, simbolis ir kt.

C kalba yra šie duomenų tipai.

Pagrindiniai duomenų tipai

Pagrindiniai duomenų tipai yra pagrįsti sveikaisiais skaičiais ir slankiojo kablelio. C kalba palaiko ir pasirašytus, ir beženklius literatus.

Pagrindinių duomenų tipų atminties dydis gali keistis priklausomai nuo 32 arba 64 bitų operacinės sistemos.

kaip išsiveržti iš amžių ciklo java

Pažiūrėkime pagrindinius duomenų tipus. Jo dydis nurodytas pagal 32 bitų architektūrą .

Tarpt.:

Sveikieji skaičiai yra sveiki skaičiai be trupmeninių ar dešimtainių dalių, ir int duomenų tipas naudojamas jiems atstovauti.

Jis dažnai taikomas kintamiesiems, kurie apima vertybes , toks kaip skaičiai, indeksai , arba kiti skaitiniai skaičiai. The int duomenų tipas gali atstovauti abiem teigiamas ir neigiami skaičiai nes jis pasirašytas pagal nutylėjimą.

An tarpt paima 4 baitai atminties daugumoje įrenginių, leidžiančių saugoti vertes nuo -2 milijardų iki +2 milijardų.

Charakteris:

Atskiri simboliai pavaizduoti char duomenų tipas . Paprastai naudojamas laikyti ASCII arba UTF-8 kodavimo schemos simboliai , toks kaip raidės, skaičiai, simboliai , arba kableliais . Yra 256 simboliai kurį galima pavaizduoti vienu simboliu, kuris užima vieną baitą atminties. Tokie personažai kaip „A“, „b“, „5“, arba '$' yra įtrauktos į atskiras kabutes.

Plūdė:

Norėdami pavaizduoti sveikuosius skaičius, naudokite plaukiojantis duomenų tipas . Slankiuosius skaičius galima naudoti trupmeniniams vienetams arba skaičiams po kablelio žymėti.

The plūdės tipas paprastai naudojamas kintamiesiems, kuriems reikalingas labai geras tikslumas, bet kurie gali būti nelabai tikslūs. Jis gali saugoti reikšmes maždaug tikslumu 6 skaitmenys po kablelio ir diapazonas apie 3,4 x 1038 in 4 baitai atminties.

Dvigubas:

Naudokite dviejų tipų duomenis du plaukiojantys sveikieji skaičiai . Kai reikalingas papildomas tikslumas, pavyzdžiui, atliekant mokslinius skaičiavimus ar finansines programas, jis užtikrina didesnį tikslumą, palyginti su plūdine.

Dvigubas tipas , kuris naudoja 8 baitai atminties ir jo tikslumas yra apie 15 skaitmenų po kablelio, gaunamos didesnės reikšmės . C pagal numatytuosius nustatymus laiko slankiojo kablelio skaičiais dvigubais, jei nepateikiamas aiškus tipas.

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

Aukščiau pateiktame pavyzdyje deklaruojame keturis kintamuosius: an int kintamasis už asmens amžių, a char kintamasis už mokinio pažymį, a plūduriuojantis kintamasis temperatūros rodmenims ir du kintamieji skaičius pi.

Išvestinis duomenų tipas

Be pagrindinių duomenų tipų, C taip pat palaiko išvestiniai duomenų tipai, įskaitant masyvai, rodyklės, struktūros, ir sąjungos . Šie duomenų tipai suteikia programuotojams galimybę tvarkyti nevienalyčius duomenis, tiesiogiai modifikuoti atmintį ir kurti sudėtingas duomenų struktūras.

Masyvas:

An masyvas, išvestinis duomenų tipas , leidžia išsaugoti seką fiksuoto dydžio elementai to paties tipo. Tai suteikia mechanizmą, leidžiantį sujungti kelis tų pačių duomenų taikinius tuo pačiu pavadinimu.

np.random.rand

Indeksas naudojamas norint pasiekti masyvo elementus su a 0 indeksas pirmam įrašui. Masyvo dydis yra fiksuotas deklaravimo metu ir negali būti keičiamas vykdant programą. Masyvo komponentai dedami į gretimas atminties sritis.

Čia yra masyvo deklaravimo ir naudojimo pavyzdys:

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

Rodyklė:

A rodyklė yra išvestinis duomenų tipas, kuris seka kito duomenų tipo atminties adresą. Kada rodyklė yra deklaruojama, duomenų tipas tai nurodo yra pareiškė pirmas , o tada kintamasis pavadinimas prieš tai yra žvaigždutė (*) .

Galite turėti neteisingą prieigą ir pakeisti kintamojo reikšmę naudodami rodykles, nurodydami kintamojo atminties adresą. Rodyklės dažniausiai naudojami užduotys toks kaip funkcijų rodyklės, duomenų struktūros , ir dinaminis atminties paskirstymas .

Čia yra žymeklio deklaravimo ir naudojimo pavyzdys:

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

Išvestis:

 Value of num: 42 

Struktūra:

Struktūra yra išvestinis duomenų tipas, leidžiantis kurti sudėtinius duomenų tipus, leidžiant grupuoti daugybę duomenų tipų vienu pavadinimu. Tai suteikia galimybę kurti savo unikalias duomenų struktūras, sujungiant įvairių rūšių kintamuosius.

java pasirinkimo rūšiavimas

1. Struktūros nariai arba laukai naudojami nurodyti kiekvienam jos kintamajam.
2. Bet koks duomenų tipas, įskaitant skirtingas struktūras, gali būti struktūros narys.
3. Struktūros elementus galima pasiekti naudojant taško (.) operatorių.

Deklaracija ir konstrukcijos naudojimas parodytas čia:

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

Išvestis:

 Name: John Doe Age: 30 Height: 1.80 

Sąjunga:

Išvestinis duomenų tipas, vadinamas a sąjunga leidžia tame pačiame atminties adresu saugoti įvairių tipų duomenis. Priešingai nei struktūros, kuriose kiekvienas narys turi atskirą atminties erdvę, visi sąjungos nariai dalijasi viena atminties erdve. Vertybę bet kuriuo momentu gali turėti tik vienas sąjungos narys. Kai daug duomenų tipų reikia pateikti pakaitomis, sąjungos pravers. Kaip ir struktūros, sąjungos narius galite pasiekti naudodami taškas (.) operatorius.

Štai sąjungos paskelbimo ir naudojimo pavyzdys:

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

Išvestis:

metodo perkrova

 Integer Value: 42 Float Value: 3.14 

Surašymo duomenų tipas

Įvardytų konstantų rinkinys arba surašinėtojai kurios atstovauja sujungtų reikšmių rinkinį, gali būti apibrėžtos C naudojant surašymo duomenų tipas (enum). Sąrašai suteiks jums galimybę suteikti prasmingus pavadinimus integraliųjų reikšmių grupei, todėl kodą lengviau skaityti ir prižiūrėti.

Štai pavyzdys, kaip apibrėžti ir naudoti sąrašą 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; } 

Išvestis:

 Today is 2 

Tuščias duomenų tipas

The tuščias duomenų tipas C kalboje vartojamas tam tikro tipo nebuvimui pažymėti. Funkcijų grąžinimo tipai, funkcijos parametrai , ir rodyklės yra trys situacijos, kai ji dažnai naudojama.

Funkcijos grąžinimo tipas:

A negaliojančio grąžinimo tipas funkcija nesukuria vertės. A tuščia funkcija įvykdo užduotį arba veiksmą ir baigia, o ne grąžina vertę.

Pavyzdys:

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

Funkciniai parametrai:

The parametras tuščias gali būti naudojamas norint nurodyti, kad funkcija nepriima jokių argumentų.

Pavyzdys:

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

Rodyklės:

Bet koks adresas gali būti išsaugotas tipo rodyklėje tuštuma* , todėl tai yra universali rodyklė. Jis siūlo metodą, kaip dirbti su rodyklėmis į dviprasmiškus ar netipinius tipus.

Pavyzdys:

"kruskal algoritmas"

 void* dataPtr; 

The tuščias duomenų tipas yra naudingas nustatant funkcijas, kurios nepriima jokių argumentų, kai dirbate su bendraisiais rodyklėmis arba kai norite signalizuoti, kad funkcija negrąžina reikšmės. Svarbu pažymėti, kad tuo metu tuštuma* gali būti naudojamas kuriant bendrąsias nuorodas, pati void negali būti deklaruojama kaip kintamojo tipas.

Čia yra kodo pavyzdys, rodantis, kaip panaudoti tuštumą įvairiose situacijose:

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

Išvestis:

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

Išvada:

Kaip rezultatas, duomenų tipai yra būtini C programavimo kalboje, nes jie apibrėžia informacijos, kurią gali turėti kintamieji, rūšis. Jie pateikia duomenų dydį ir formatą, leidžiantį kompiliatoriui skirti atmintį ir atlikti reikiamus veiksmus. C palaikomi duomenų tipai apima niekinis, surašymas, išvestinė , ir pagrindiniai tipai . Be slankiojo kablelio tipų, pvz plūdė ir dvigubai , pagrindiniai duomenų tipai C taip pat apima sveikųjų skaičių pagrindus, pvz., int, char , ir trumpas . Šios formos gali būti pasirašyta arba nepasirašytas , o jų dydis ir diapazonas svyruoja. Norint sukurti patikimą ir efektyvų kodą, labai svarbu suprasti šių tipų atminties dydį ir apimtį.

Keletas pavyzdžių išvestinių duomenų tipai yra sąjungos, rodyklės, struktūros , ir masyvai . Dėl masyvų gretimoje atmintyje gali būti saugomi keli tos pačios rūšies elementai. Rodyklės Sekite atminties adresus, kad būtų galima greitai atlikti duomenų struktūros operacijas ir dinamiškai paskirstyti atmintį. Nors sąjungos leidžia daugeliui kintamųjų dalytis ta pačia atminties vieta, o struktūros sugrupuoja atitinkamus kintamuosius.

Kodas tampa aiškesnis ir lengviau prižiūrimas, kai įvardintos konstantos apibrėžiamos naudojant surašymo duomenų tipus. Sąrašai suteikite vardines konstantas sveikųjų skaičių reikšmes, kad būtų galima prasmingai pavaizduoti susijusius duomenis. Tuščiųjų duomenų tipas rodo, kad nėra konkretaus tipo. Jis naudojamas kaip grąžinimo tipas abiem funkcijas ir funkcijos parametrai kurie nepriima jokių argumentų ir negrąžina vertės. The tuščias* rodyklė taip pat veikia kaip bendras rodyklė, kuri gali parduotuvių adresai įvairių tipų.

C programavimas reikalauja tvirto supratimo duomenų tipai . Programuotojai gali užtikrinti tinkamą atminties paskirstymą, vengti duomenų perpildymas arba sutrumpinimas , ir pagerinkite jų kodo skaitomumą bei priežiūrą pasirinkdami tinkamą duomenų tipas . C programuotojai gali kurti efektyvus, patikimas , ir gerai struktūrizuotą kodą, atitinkantį jų taikomųjų programų reikalavimus, nes gerai supranta duomenų tipus.