En datatype spesifiserer typen data som en variabel kan lagre, for eksempel heltall, flytende, tegn osv.

Det er følgende datatyper i C-språk.

Grunnleggende datatyper

De grunnleggende datatypene er heltallsbaserte og flyttallsbaserte. C-språk støtter både signerte og usignerte bokstaver.

Minnestørrelsen til de grunnleggende datatypene kan endres i henhold til 32- eller 64-biters operativsystem.

powershell kommentar multiline

La oss se de grunnleggende datatypene. Størrelsen er gitt i henhold til 32-bits arkitektur .

Int:

Heltall er hele tall uten brøk- eller desimaldeler, og int datatype brukes til å representere dem.

Det brukes ofte på variabler som inkluderer verdier , som for eksempel teller, indekser , eller andre numeriske tall. De int datatype kan representere begge positivt og negative tall fordi den er signert som standard.

An int tar opp 4 byte minne på de fleste enheter, slik at den kan lagre verdier mellom rundt -2 milliarder og +2 milliarder.

Char:

Individuelle tegn er representert av char datatype . Brukes vanligvis til å holde ASCII eller UTF-8-kodeskjemategn , som for eksempel bokstaver, tall, symboler , eller komma . Det er 256 tegn som kan representeres av et enkelt tegn, som tar opp en byte med minne. Karakterer som f.eks 'A', 'b', '5', eller '$' er vedlagt enkle anførselstegn.

Flyte:

For å representere heltall, bruk flytende datatype . Flytende tall kan brukes til å representere brøkenheter eller tall med desimaler.

java server sider

De flytetype brukes vanligvis for variabler som krever veldig god presisjon, men som kanskje ikke er veldig presise. Den kan lagre verdier med en nøyaktighet på ca 6 desimaler og en rekke på ca 3,4 x 1038 i 4 byte av minne.

Dobbelt:

Bruk to datatyper for å representere to flytende heltall . Når det er behov for ytterligere presisjon, for eksempel i vitenskapelige beregninger eller økonomiske applikasjoner, gir det større nøyaktighet sammenlignet med float.

Dobbel type , som bruker 8 byte av hukommelse og har en nøyaktighet på ca 15 desimaler, gir større verdier . C behandler som standard flyttall som doble hvis ingen eksplisitt type er oppgitt.

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

I eksemplet ovenfor erklærer vi fire variabler: an int variabel for personens alder, a char variabel for elevens karakter, a flyte variabel for temperaturavlesningen, og to variabler for nummer pi.

Avledet datatype

Utover de grunnleggende datatypene, støtter C også avledede datatyper, gjelder også matriser, pekere, strukturer, og fagforeninger . Disse datatypene gir programmerere muligheten til å håndtere heterogene data, direkte modifisere minne og bygge kompliserte datastrukturer.

Matrise:

An array, en avledet datatype , lar deg lagre en sekvens av elementer i fast størrelse av samme type. Det gir en mekanisme for å slå sammen flere mål med samme data under samme navn.

Indeksen brukes til å få tilgang til elementene i arrayet, med en 0 indeks for den første oppføringen. Størrelsen på arrayet er fast på deklarasjonstidspunktet og kan ikke endres under programkjøring. Matrisekomponentene er plassert i tilstøtende minneområder.

Her er et eksempel på å deklarere og bruke en matrise:

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

Peker:

EN pekeren er en avledet datatype som holder styr på en annen datatypes minneadresse. Når en pekeren er erklært, den data-type det refererer til er oppgitt først , og deretter variabelnavn er innledet med en stjerne (*) .

Du kan ha feil tilgang og endre verdien til variabel ved å bruke pekere ved å spesifisere minneadressen til variabelen. Pekere er ofte brukt i oppgaver som for eksempel funksjonspekere, datastrukturer , og dynamisk minnetildeling .

Her er et eksempel på å deklarere og bruke en peker:

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

Produksjon:

 Value of num: 42 

Struktur:

En struktur er en avledet datatype som gjør det mulig å lage sammensatte datatyper ved å tillate gruppering av mange datatyper under ett enkelt navn. Det gir deg muligheten til å lage dine egne unike datastrukturer ved å smelte sammen variabler av ulike slag.

manuell testing

1. En strukturs medlemmer eller felt brukes til å referere til hver variabel i den.
2. Enhver datatype, inkludert ulike strukturer, kan være medlem av en struktur.
3. En strukturs medlemmer kan nås ved å bruke prikken (.)-operatoren.

En erklæring og bruk av en struktur demonstreres her:

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

Produksjon:

 Name: John Doe Age: 30 Height: 1.80 

Union:

En avledet datatype kalt a fagforening lar deg lagre ulike datatyper i samme minneadresse. I motsetning til strukturer, der hvert medlem har en egen minneplass, deler medlemmer av en fagforening en enkelt minneplass. En verdi kan bare innehas av ett medlem av en fagforening til enhver tid. Når du trenger å representere mange datatyper om hverandre, kommer fagforeninger godt med. I likhet med strukturer kan du få tilgang til medlemmene i en fagforening ved å bruke punktum (.) operatør.

Her er et eksempel på at en fagforening blir erklært og brukt:

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

Produksjon:

 Integer Value: 42 Float Value: 3.14 

Oppregningsdatatype

Et sett med navngitte konstanter eller tellere som representerer en samling av tilkoblede verdier kan defineres i C ved å bruke oppregningsdatatype (enum). Oppregninger gi deg muligheten til å gi navn som gir mening til en gruppe av integrerte verdier, noe som gjør koden din enklere å lese og vedlikeholde.

Her er et eksempel på hvordan du definerer og bruker en oppregning i 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; } 

Produksjon:

 Today is 2 

Ugyldig datatype

De ugyldig datatype i C brukes språket for å betegne mangelen på en bestemt type. Funksjonsreturtyper, funksjonsparametere , og pekere er tre situasjoner der det brukes ofte.

Funksjonsreturtype:

EN ugyldig returtype funksjonen produserer ikke en verdi. EN ugyldig funksjon utfører en oppgave eller handling og avslutter i stedet for å returnere en verdi.

Eksempel:

kutte java

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

Funksjonsparametre:

De parameter ugyldig kan brukes til å indikere at en funksjon ikke aksepterer argumenter.

Eksempel:

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

Pekere:

Enhver adresse kan lagres i en peker av typen tomrom* , noe som gjør det til en universell peker. Den tilbyr en metode for å arbeide med pekere til tvetydige eller atypiske typer.

Eksempel:

 void* dataPtr; 

De ugyldig datatype er nyttig for å definere funksjoner som ikke aksepterer noen argumenter når du arbeider med generiske pekere eller når du ønsker å signalisere at en funksjon ikke returnerer en verdi. Det er viktig å merke seg at mens tomrom* kan brukes til å bygge generiske pekere, selve void kan ikke deklareres som en variabeltype.

Her er et eksempel på kode som viser hvordan du kan bruke void i ulike situasjoner:

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

Produksjon:

python-baneinnstilling

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

Konklusjon:

Som et resultat, datatyper er essensielle i programmeringsspråket C fordi de definerer typen informasjon som variabler kan inneholde. De gir dataenes størrelse og format, slik at kompilatoren kan tildele minne og utføre de nødvendige handlingene. Datatyper som støttes av C inkluderer tomhet, oppregning, avledet , og grunnleggende typer . I tillegg til flytende kommatyper som flyte og dobbelt , grunnleggende datatyper i C inkluderer også heltallsbaserte typer som int, char , og kort . Disse skjemaene kan være signert eller usignert , og de varierer i størrelse og rekkevidde. For å lage pålitelig og effektiv kode, er det avgjørende å forstå minnestørrelsen og omfanget av disse typene.

Noen få eksempler på avledede datatyper er fagforeninger, pekere, strukturer , og matriser . Flere elementer av samme type kan lagres sammen i sammenhengende minne på grunn av arrays. Pekere holde styr på minneadresser, noe som gir raske datastrukturoperasjoner og dynamisk minneallokering. Samtidig som fagforeninger lar mange variabler dele samme minneplass, strukturer grupperer relevante variabler sammen.

Kode blir mer lesbar og vedlikeholdbar når navngitte konstanter defineres ved hjelp av oppregningsdatatyper. Oppregninger gi navngitte konstanter heltallsverdier for å muliggjøre meningsfull representasjon av relaterte data. Ugyldig datatype indikerer mangelen på en bestemt type. Den brukes som returtype for begge funksjoner og funksjonsparametere som ikke tar noen argumenter og ikke returnerer en verdi. De void* peker fungerer også som en generell pekepinn som kan butikkadresser av ulike typer.

C-programmering krever en solid forståelse av datatyper . Programmerere kan sikre tilstrekkelig minnetildeling, unngå dataoverflyt eller trunkering , og forbedre lesbarheten og vedlikeholdsvennligheten til koden deres ved å velge riktig data-type . C-programmerere kan lage effektiv, pålitelig , og velstrukturert kode som tilfredsstiller kravene til applikasjonene deres ved å ha en solid forståelse av datatyper.