TechCodeview

En datatyp anger vilken typ av data som en variabel kan lagra såsom heltal, flytande, tecken, etc.

Det finns följande datatyper i C-språk.

Grundläggande datatyper

De grundläggande datatyperna är heltalsbaserade och flyttalsbaserade. C-språket stöder både signerade och osignerade bokstaver.

Minnesstorleken för de grundläggande datatyperna kan ändras beroende på 32- eller 64-bitars operativsystem.

anaconda vs pythonorm

Låt oss se de grundläggande datatyperna. Dess storlek anges enligt 32-bitars arkitektur .

Int:

Heltal är hela tal utan bråk- eller decimaldelar, och int datatyp används för att representera dem.

Det tillämpas ofta på variabler som inkluderar värden , Till exempel räknar, index , eller andra numeriska nummer. De int datatyp kan representera båda positiv och negativa tal eftersom den är signerad som standard.

En int tar upp 4 bytes minne på de flesta enheter, vilket gör att den kan lagra värden mellan cirka -2 miljarder och +2 miljarder.

Röding:

Individuella karaktärer representeras av char datatyp . Används vanligtvis för att hålla ASCII eller UTF-8-kodningsschematecken , Till exempel bokstäver, siffror, symboler , eller kommatecken . Det finns 256 tecken som kan representeras av ett enda tecken, som tar upp en byte minne. Karaktärer som t.ex 'A', 'b', '5', eller '$' är omslutna av enstaka citattecken.

Flyta:

För att representera heltal, använd flytande datatyp . Flytande tal kan användas för att representera bråkenheter eller tal med decimaler.

De flyttyp används vanligtvis för variabler som kräver mycket god precision men som kanske inte är särskilt exakta. Den kan lagra värden med en noggrannhet på ca 6 decimaler och ett utbud på ca 3,4 x 1038 i 4 bytes av minnet.

Dubbel:

Använd två datatyper för att representera två flytande heltal . När ytterligare precision behövs, till exempel i vetenskapliga beräkningar eller finansiella tillämpningar, ger det större noggrannhet jämfört med float.

Dubbel typ , som använder 8 byte av minne och har en noggrannhet på ca 15 decimaler, ger större värden . C behandlar flyttalsnummer som dubbla som standard om ingen explicit typ tillhandahålls.

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

I exemplet ovan deklarerar vi fyra variabler: an int variabel för personens ålder, a char variabel för elevens betyg, a flytvariabel för temperaturavläsningen och två variabler för nummer pi.

Härledd datatyp

Utöver de grundläggande datatyperna stöder C också härledda datatyper, Inklusive matriser, pekare, strukturer, och fackföreningar . Dessa datatyper ger programmerare möjlighet att hantera heterogena data, direkt modifiera minne och bygga komplicerade datastrukturer.

Array:

En array, en härledd datatyp , låter dig lagra en sekvens av element i fast storlek av samma typ. Det tillhandahåller en mekanism för att sammanfoga flera mål med samma data under samma namn.

java ansluta med mysql

Indexet används för att komma åt elementen i arrayen, med en 0 index för den första posten. Storleken på arrayen är fast vid deklarationstidpunkten och kan inte ändras under programkörning. Arraykomponenterna är placerade i angränsande minnesområden.

Här är ett exempel på att deklarera och använda en array:

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

Pekare:

A pekare är en härledd datatyp som håller reda på en annan datatyps minnesadress. När en pekare deklareras, den data typ det syftar på är angav först , och sedan variabelnamn föregås av en asterisk (*) .

Du kan ha felaktig åtkomst och ändra värdet på variabel med hjälp av pekare genom att ange minnesadressen för variabeln. Pekare används ofta i uppgifter Till exempel funktionspekare, datastrukturer , och dynamisk minnesallokering .

Här är ett exempel på att deklarera och använda en pekare:

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

Produktion:

 Value of num: 42 

Strukturera:

En struktur är en härledd datatyp som möjliggör skapandet av sammansatta datatyper genom att tillåta gruppering av många datatyper under ett enda namn. Det ger dig möjligheten att skapa dina egna unika datastrukturer genom att smälta samman variabler av olika slag.

hur många miljoner är det i en miljard

1. En strukturs medlemmar eller fält används för att referera till varje variabel i den.
2. Alla datatyper, inklusive olika strukturer, kan vara medlemmar i en struktur.
3. En strukturs medlemmar kan nås genom att använda punktoperatorn (.).

En deklaration och användning av en struktur visas här:

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

Produktion:

 Name: John Doe Age: 30 Height: 1.80 

Union:

En härledd datatyp som kallas a union gör att du kan lagra olika datatyper i samma minnesadress. I motsats till strukturer, där varje medlem har ett separat minnesutrymme, delar alla medlemmar i en fackförening ett enda minnesutrymme. Ett värde kan endast innehas av en medlem i ett fackförbund vid varje givet tillfälle. När du behöver representera många datatyper omväxlande, kommer fackföreningar väl till pass. Precis som strukturer kan du komma åt medlemmarna i en fackförening genom att använda prick (.) operatör.

Här är ett exempel på att en fackförening deklareras och används:

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

Produktion:

Java typ av variabel

 Integer Value: 42 Float Value: 3.14 

Uppräkningsdatatyp

En uppsättning namngivna konstanter eller uppräknare som representerar en samling anslutna värden kan definieras i C med hjälp av uppräkningsdatatyp (enum). Uppräkningar ger dig möjlighet att ge namn som är vettiga för en grupp av integralvärden, vilket gör din kod lättare att läsa och underhålla.

Här är ett exempel på hur man definierar och använder en uppräkning 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; } 

Produktion:

 Today is 2 

Ogiltig datatyp

De ogiltig datatyp i C används språket för att beteckna avsaknaden av en viss typ. Funktionsreturtyper, funktionsparametrar , och pekare är tre situationer där det används ofta.

Funktion Returtyp:

A ogiltig returtyp funktion ger inget värde. A ogiltig funktion utför en uppgift eller åtgärd och avslutar snarare än att returnera ett värde.

Exempel:

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

Funktionsparametrar:

De parameter ogiltig kan användas för att indikera att en funktion inte accepterar några argument.

Exempel:

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

Tips:

Vilken adress som helst kan lagras i en pekare av typ tomhet* , vilket gör det till en universell pekare. Den erbjuder en metod för att arbeta med pekare till tvetydiga eller atypiska typer.

Exempel:

15 av 100,00

 void* dataPtr; 

De ogiltig datatyp är användbart för att definiera funktioner som inte accepterar några argument när du arbetar med generiska pekare eller när du vill signalera att en funktion inte returnerar ett värde. Det är viktigt att notera att medan tomhet* kan användas för att bygga generiska pekare, void i sig kan inte deklareras som en variabeltyp.

Här är ett exempel på kod som visar hur man använder void i olika situationer:

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

Produktion:

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

Slutsats:

Som ett resultat, datatyper är viktiga i programmeringsspråket C eftersom de definierar den typ av information som variabler kan innehålla. De tillhandahåller datans storlek och format, vilket gör det möjligt för kompilatorn att tilldela minne och utföra nödvändiga åtgärder. Datatyper som stöds av C inkluderar tomrum, uppräkning, härledd , och grundläggande typer . Förutom flyttalstyper som flyta och dubbel , grundläggande datatyper i C inkluderar också heltalsbaserade typer som int, char , och kort . Dessa former kan vara signerad eller osignerad , och de varierar i storlek och intervall. För att skapa pålitlig och effektiv kod är det avgörande att förstå minnesstorleken och omfattningen av dessa typer.

Några exempel på härledda datatyper är fackföreningar, tips, strukturer , och matriser . Flera element av samma slag kan lagras tillsammans i sammanhängande minne på grund av arrayer. Pekare hålla reda på minnesadresser, vilket möjliggör snabba datastrukturoperationer och dynamisk minnesallokering. Medan fackföreningar tillåter många variabler att dela samma minnesutrymme, strukturer grupperar relevanta variabler tillsammans.

Koda blir mer läsbar och underhållbar när namngivna konstanter definieras med hjälp av uppräkningsdatatyper. Uppräkningar ge namngivna konstanter heltalsvärden för att möjliggöra en meningsfull representation av relaterade data. Den ogiltiga datatypen indikerar avsaknaden av en viss typ. Den används som returtyp för båda funktioner och funktionsparametrar som inte tar några argument och inte returnerar ett värde. De tom* pekare fungerar också som en allmän pekare som kan butiksadresser av olika slag.

C-programmering kräver en gedigen förståelse för datatyper . Programmerare kan säkerställa tillräcklig minnesallokering, undvika dataspill eller avkortning , och förbättra läsbarheten och underhållbarheten för deras kod genom att välja rätt data typ . C-programmerare kan skapa effektiv, pålitlig , och välstrukturerad kod som uppfyller kraven för deras applikationer genom att ha en gedigen förståelse för datatyper.