Un tip de date specifică tipul de date pe care o variabilă le poate stoca, cum ar fi întreg, flotant, caracter etc.

Există următoarele tipuri de date în limbajul C.

Tipuri de date de bază

Tipurile de date de bază sunt bazate pe numere întregi și pe virgulă mobilă. Limbajul C acceptă atât literale semnate, cât și nesemnate.

Dimensiunea memoriei tipurilor de date de bază se poate modifica în funcție de sistemul de operare pe 32 sau 64 de biți.

Linux schimba numele directorului

Să vedem tipurile de date de bază. Mărimea lui este dată conform arhitecturii pe 32 de biți .

Int:

numere întregi sunt numere întregi fără părți fracționale sau zecimale și int tipul de date este folosit pentru a le reprezenta.

Se aplică frecvent variabilelor care includ valorile , ca numărări, indici , sau alte numere numerice. The int tipul de date poate reprezenta pe amândouă pozitiv și numere negative deoarece este semnat implicit.

Un int preia 4 octeți de memorie pe majoritatea dispozitivelor, permițându-i să stocheze valori între aproximativ -2 miliarde și +2 miliarde.

Char:

Caracterele individuale sunt reprezentate de tipul de date char . De obicei folosit pentru a ține ASCII sau Caractere ale schemei de codare UTF-8 , ca litere, cifre, simboluri , sau virgule . Sunt 256 de caractere care poate fi reprezentat printr-un singur caracter, care ocupă un octet de memorie. Personaje precum „A”, „b”, „5”, sau '$' sunt cuprinse între ghilimele simple.

Pluti:

Pentru a reprezenta numere întregi, utilizați tip de date plutitoare . Numerele flotante pot fi folosite pentru a reprezenta unități fracționale sau numere cu zecimale.

The tip plutitor este de obicei folosit pentru variabile care necesită o precizie foarte bună, dar care pot să nu fie foarte precise. Poate stoca valori cu o precizie de aproximativ 6 zecimale si o gama de aproximativ 3,4 x 1038 în 4 octeți de memorie.

Dubla:

Utilizați două tipuri de date pentru a reprezenta două numere întregi plutitoare . Atunci când este nevoie de o precizie suplimentară, cum ar fi calculele științifice sau aplicațiile financiare, aceasta oferă o precizie mai mare în comparație cu float.

Tip dublu , care folosește 8 octeți de memorie și are o precizie de aproximativ 15 zecimale, dă valori mai mari . C tratează numerele în virgulă mobilă ca duble în mod implicit dacă nu este furnizat niciun tip explicit.

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

În exemplul de mai sus, declarăm patru variabile: an variabilă int pentru vârsta persoanei, a variabila char pentru nota elevului, a variabilă float pentru citirea temperaturii și două variabile pentru numărul pi.

Tip de date derivate

Dincolo de tipurile fundamentale de date, C acceptă și tipuri de date derivate, inclusiv matrice, pointeri, structuri, și sindicatele . Aceste tipuri de date oferă programatorilor capacitatea de a gestiona date eterogene, de a modifica direct memoria și de a construi structuri complicate de date.

Matrice:

Un matrice, un tip de date derivat , vă permite să stocați o secvență de elemente de dimensiuni fixe de acelasi tip. Acesta oferă un mecanism pentru unirea mai multor ținte ale acelorași date sub același nume.

Indexul este folosit pentru a accesa elementele matricei, cu a 0 index pentru prima intrare. Dimensiunea matricei este fixată în momentul declarației și nu poate fi modificată în timpul execuției programului. Componentele matricei sunt plasate în regiuni de memorie adiacente.

Iată un exemplu de declarare și utilizare a unei matrice:

tutorial java swing

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

Indicator:

A indicator este un tip de date derivat care ține evidența adresei de memorie a altui tip de date. Când un indicator se declară, the tip de date se referă la este a declarat mai întâi , iar apoi numele variabilei este precedat de un asterisc (*) .

Puteți avea acces incorect și puteți modifica valoarea variabilei folosind pointeri specificând adresa de memorie a variabilei. Indicatori sunt utilizate în mod obișnuit în sarcini ca indicatori de funcții, structuri de date , și alocare dinamică a memoriei .

Iată un exemplu de declarare și utilizare a unui 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; } 

Ieșire:

 Value of num: 42 

Structura:

O structură este un tip de date derivat care permite crearea de tipuri de date compuse, permițând gruparea mai multor tipuri de date sub un singur nume. Vă oferă posibilitatea de a vă crea propriile structuri de date unice prin fuzionarea variabilelor de diferite tipuri.

forma completă a i d e

1. Membrii sau câmpurile unei structuri sunt folosite pentru a se referi la fiecare variabilă din cadrul acesteia.
2. Orice tip de date, inclusiv diferite structuri, poate fi membru al unei structuri.
3. Membrii unei structuri pot fi accesați utilizând operatorul punct (.).

O declarație și utilizarea unei structuri este demonstrată aici:

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

Ieșire:

 Name: John Doe Age: 30 Height: 1.80 

Uniune:

Un tip de date derivat numit a uniune vă permite să stocați diferite tipuri de date în aceeași adresă de memorie. Spre deosebire de structurile, în care fiecare membru are un spațiu de memorie separat, membrii unei uniuni împărtășesc un singur spațiu de memorie. O valoare poate fi deținută doar de un membru al unui sindicat la un moment dat. Când trebuie să reprezentați mai multe tipuri de date în mod interschimbabil, uniunile sunt utile. La fel ca structurile, puteți accesa membrii unei uniuni utilizând punct (.) operator.

Iată un exemplu de uniune care este declarată și utilizată:

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

Ieșire:

 Integer Value: 42 Float Value: 3.14 

Tip de date de enumerare

Un set de constante numite sau enumeratori care reprezintă o colecție de valori conectate pot fi definite în C folosind tipul de date de enumerare (enum). Enumerări vă oferă mijloacele de a da nume care au sens unui grup de valori integrale, ceea ce face codul mai ușor de citit și de întreținut.

regex în java

Iată un exemplu despre cum să definiți și să utilizați o enumerare în 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; } 

Ieșire:

 Today is 2 

Tip de date nul

The tip de date nul în limbajul C este folosit pentru a desemna lipsa unui anumit tip. Tipuri de returnare a funcției, parametrii funcției , și indicatoare sunt trei situații în care este utilizat frecvent.

Tip de returnare a funcției:

A tip de returnare nulă funcția nu produce o valoare. A funcția de gol execută o sarcină sau o acțiune și se încheie mai degrabă decât să returneze o valoare.

Exemplu:

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

Parametrii funcției:

The parametru nul poate fi folosit pentru a indica faptul că o funcție nu acceptă argumente.

Exemplu:

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

Indicatori:

Orice adresă poate fi stocată într-un pointer de tip gol* , făcându-l un indicator universal. Oferă o metodă de lucru cu indicatorii către tipuri ambigue sau atipice.

Exemplu:

 void* dataPtr; 

The tip de date nul este util pentru definirea funcțiilor care nu acceptă niciun argument atunci când lucrați cu pointeri generici sau când doriți să semnalați că o funcție nu returnează o valoare. Este semnificativ de observat că în timp ce gol* poate fi folosit pentru a construi pointeri generici, void în sine nu poate fi declarat ca tip variabil.

Iată un eșantion de cod care arată cum să utilizați void în diferite situații:

c matrice de șiruri de caractere

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

Ieșire:

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

Concluzie:

Ca urmare, tipuri de date sunt esențiale în limbajul de programare C, deoarece definesc tipurile de informații pe care variabilele le pot deține. Acestea furnizează dimensiunea și formatul datelor, permițând compilatorului să aloce memorie și să efectueze acțiunile necesare. Tipurile de date acceptate de C includ vid, enumerare, derivat , și tipuri de bază . Pe lângă tipurile în virgulă mobilă, cum ar fi pluti și dubla , tipurile de date de bază în C includ și tipuri bazate pe numere întregi, cum ar fi int, char , și mic de statura . Aceste forme pot fi semnat sau nesemnat și fluctuează în dimensiune și gamă. Pentru a crea cod de încredere și eficient, este esențial să înțelegeți dimensiunea memoriei și domeniul de aplicare a acestor tipuri.

Câteva exemple de tipuri de date derivate sunt uniuni, indicatoare, structuri , și matrice . Mai multe elemente de același fel pot fi stocate împreună în memoria contiguă datorită tablourilor. Indicatori ține evidența adreselor de memorie, permițând operațiuni rapide de structură a datelor și alocarea dinamică a memoriei. In timp ce sindicatele permit mai multor variabile să partajeze același spațiu de memorie, structurile grupează variabilele relevante împreună.

Cod devine mai lizibilă și mai ușor de întreținut atunci când constantele numite sunt definite folosind tipuri de date de enumerare. Enumerări dați constantelor numite valori întregi pentru a permite reprezentarea semnificativă a datelor înrudite. Tipul de date nul indică lipsa unui anumit tip. Este folosit ca tip de returnare pentru ambele funcții și parametrii funcției care nu iau argumente și nu returnează o valoare. The void* pointer funcționează și ca un indicator general care poate adresele magazinelor de diverse tipuri.

Programarea C necesită o înțelegere solidă a tipuri de date . Programatorii pot asigura alocarea adecvată a memoriei, evitați overflow de date sau trunchiere , și sporește lizibilitatea și mentenabilitatea codului lor prin selectarea corectă tip de date . Programatorii C pot crea eficient, de încredere , și cod bine structurat care satisface cerințele aplicațiilor lor, având o înțelegere fermă a tipurilor de date.