Un tipo de datos especifica el tipo de datos que una variable puede almacenar, como enteros, flotantes, de caracteres, etc.

Existen los siguientes tipos de datos en lenguaje C.

Tipos de datos básicos

Los tipos de datos básicos están basados ​​en números enteros y en punto flotante. El lenguaje C admite literales con y sin signo.

El tamaño de la memoria de los tipos de datos básicos puede cambiar según el sistema operativo de 32 o 64 bits.

lanzar int a cadena

Veamos los tipos de datos básicos. Su tamaño esta dado según arquitectura de 32 bits .

En t:

Enteros son números enteros sin partes fraccionarias o decimales, y el tipo de datos int se utiliza para representarlos.

Se aplica frecuentemente a variables que incluyen valores , como recuentos, índices u otros números numéricos. El tipo de datos int puede representar ambos positivo y números negativos porque está firmado por defecto.

Un En t ocupa 4 bytes de memoria en la mayoría de los dispositivos, lo que le permite almacenar valores entre alrededor de -2 mil millones y +2 mil millones.

Carbonizarse:

Los personajes individuales están representados por el tipo de datos de carácter . Normalmente se utiliza para sostener ASCII o Caracteres del esquema de codificación UTF-8 , como letras, números, símbolos , o comas . Hay 256 caracteres que puede representarse mediante un solo carácter, que ocupa un byte de memoria. Personajes como 'A', 'b', '5', o '$' están entre comillas simples.

Flotar:

Para representar números enteros, utilice el tipo de datos flotante . Los números flotantes se pueden utilizar para representar unidades fraccionarias o números con decimales.

El tipo flotante Generalmente se usa para variables que requieren muy buena precisión pero que pueden no ser muy precisas. Puede almacenar valores con una precisión de aproximadamente 6 decimales y una gama de aproximadamente 3,4x1038 en 4 bytes de la memoria.

orden lexicográfico

Doble:

Utilice dos tipos de datos para representar dos enteros flotantes . Cuando se necesita precisión adicional, como en cálculos científicos o aplicaciones financieras, proporciona una mayor precisión en comparación con el flotador.

tipo doble , que utiliza 8 bytes de memoria y tiene una precisión de aproximadamente 15 decimales, produce valores más grandes . C trata los números de coma flotante como dobles de forma predeterminada si no se proporciona ningún tipo explícito.

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

En el ejemplo anterior, declaramos cuatro variables: una variable entera para la edad de la persona, un variable de carácter para la calificación del estudiante, un variable flotante para la lectura de temperatura, y dos variables para la número pi.

Tipo de datos derivados

Más allá de los tipos de datos fundamentales, C también admite tipos de datos derivados, incluido matrices, punteros, estructuras, y sindicatos . Estos tipos de datos brindan a los programadores la capacidad de manejar datos heterogéneos, modificar directamente la memoria y crear estructuras de datos complicadas.

Formación:

Un matriz, un tipo de datos derivado , le permite almacenar una secuencia de elementos de tamaño fijo del mismo tipo. Proporciona un mecanismo para unir múltiples objetivos de los mismos datos bajo el mismo nombre.

El índice se utiliza para acceder a los elementos del array, con un 0 índice para la primera entrada. El tamaño de la matriz se fija en el momento de la declaración y no se puede cambiar durante la ejecución del programa. Los componentes de la matriz se colocan en regiones de memoria adyacentes.

A continuación se muestra un ejemplo de declaración y utilización de una matriz:

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

Puntero:

A puntero es un tipo de datos derivado que realiza un seguimiento de la dirección de memoria de otro tipo de datos. Cuando un puntero se declara, el tipo de datos se refiere a es declarado primero , y luego el nombre de la variable está precedido por Un asterisco (*) .

Puede tener acceso incorrecto y cambiar el valor de la variable usando punteros especificando la dirección de memoria de la variable. Consejos se utilizan comúnmente en tareas como punteros de función, estructuras de datos , y asignación de memoria dinámica .

A continuación se muestra un ejemplo de declaración y empleo de un puntero:

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

Producción:

 Value of num: 42 

Estructura:

Una estructura es un tipo de datos derivado que permite la creación de tipos de datos compuestos al permitir la agrupación de muchos tipos de datos bajo un solo nombre. Le brinda la posibilidad de crear sus propias estructuras de datos únicas fusionando variables de varios tipos.

tipos de arbol binario

1. Los miembros o campos de una estructura se utilizan para hacer referencia a cada variable dentro de ella.
2. Cualquier tipo de datos, incluidas diferentes estructuras, puede ser miembro de una estructura.
3. Se puede acceder a los miembros de una estructura utilizando el operador punto (.).

Aquí se demuestra una declaración y el uso de una estructura:

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

Producción:

 Name: John Doe Age: 30 Height: 1.80 

Unión:

Un tipo de datos derivado llamado Unión le permite almacenar varios tipos de datos en la misma dirección de memoria. A diferencia de las estructuras, donde cada miembro tiene un espacio de memoria separado, todos los miembros de una unión comparten un único espacio de memoria. Un valor sólo puede ser mantenido por un miembro de un sindicato en un momento dado. Cuando necesitas representar muchos tipos de datos de manera intercambiable, las uniones resultan útiles. Al igual que las estructuras, puede acceder a los miembros de un sindicato utilizando el punto (.) operador.

A continuación se muestra un ejemplo de una unión declarada y utilizada:

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

Producción:

 Integer Value: 42 Float Value: 3.14 

Tipo de datos de enumeración

Un conjunto de constantes con nombre o enumeradores que representan una colección de valores conectados se pueden definir en C usando el tipo de datos de enumeración (enum). Enumeraciones le brinda los medios para dar nombres que tengan sentido a un grupo de valores integrales, lo que hace que su código sea más fácil de leer y mantener.

A continuación se muestra un ejemplo de cómo definir y utilizar una enumeración en 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; } 

Producción:

controlador web

 Today is 2 

Tipo de datos anulados

El tipo de datos nulo en lenguaje C se usa para denotar la falta de un tipo particular. Tipos de retorno de funciones, parámetros de funciones , y punteros Hay tres situaciones en las que se utiliza con frecuencia.

Tipo de retorno de función:

A tipo de devolución nula La función no produce un valor. A función nula ejecuta una tarea o acción y finaliza en lugar de devolver un valor.

Ejemplo:

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

Parámetros de función:

El parámetro nulo se puede utilizar para indicar que una función no acepta argumentos.

Ejemplo:

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

Consejos:

Cualquier dirección se puede almacenar en un puntero de tipo vacío* , convirtiéndolo en un puntero universal. Ofrece un método para trabajar con punteros a tipos ambiguos o atípicos.

Ejemplo:

 void* dataPtr; 

El tipo de datos nulo es útil para definir funciones que no aceptan ningún argumento cuando se trabaja con punteros genéricos o cuando desea señalar que una función no devuelve un valor. Es significativo señalar que si bien vacío* se puede utilizar para crear punteros genéricos, el vacío en sí no se puede declarar como un tipo de variable.

Aquí hay un ejemplo de código que muestra cómo utilizar void en diversas situaciones:

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

Producción:

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

Conclusión:

Como resultado, tipos de datos son esenciales en el lenguaje de programación C porque definen los tipos de información que pueden contener las variables. Proporcionan el tamaño y formato de los datos, lo que permite al compilador asignar memoria y realizar las acciones necesarias. Los tipos de datos soportados por C incluyen nulo, enumeración, derivado , y Tipos basicos . Además de los tipos de punto flotante como flotar y doble , los tipos de datos básicos en C también incluyen tipos basados ​​en números enteros como int, carbón , y corto . Estas formas pueden ser firmado o no firmado , y fluctúan en tamaño y alcance. Para crear código confiable y eficiente, es fundamental comprender el tamaño de la memoria y el alcance de estos tipos.

alquilar mapa

Algunos ejemplos de tipos de datos derivados son uniones, punteros, estructuras , y matrices . Se pueden almacenar varios elementos del mismo tipo juntos en una memoria contigua gracias a las matrices. Consejos realice un seguimiento de las direcciones de memoria, lo que permite operaciones rápidas de estructura de datos y asignación dinámica de memoria. Mientras sindicatos permiten que numerosas variables compartan el mismo espacio de memoria, las estructuras agrupan variables relevantes.

Código se vuelve más legible y fácil de mantener cuando las constantes con nombre se definen utilizando tipos de datos de enumeración. Enumeraciones proporcione valores enteros de constantes con nombre para permitir la representación significativa de datos relacionados. El tipo de datos nulo indica la falta de un tipo particular. Se utiliza como tipo de devolución para ambos. funciones y parámetros de función que no toma ningún argumento y no devuelve un valor. El puntero vacío * también funciona como un puntero general que puede direcciones de tiendas de varios tipos.

La programación en C requiere una sólida comprensión de tipos de datos . Los programadores pueden garantizar una asignación de memoria adecuada y evitar desbordamiento de datos o truncamiento y mejorar la legibilidad y mantenibilidad de su código seleccionando el correcto tipo de datos . Los programadores de C pueden crear eficaz, confiable y código bien estructurado que satisfaga los requisitos de sus aplicaciones al tener un conocimiento firme de los tipos de datos.