CENTRO UNIVERSITARIO DE CIENCIAS EXACTAS E INGENIERIAS

División de Tecnologías para la Integración Ciber-humana

Departamento de Ciencias Computacionales

TAREA NO. 1

TEMAS:
1) Campo
2) Registro
3) Registro de longitud fija
4) Registro de longitud variable
5) Delimitadores

Estudiante: Ramírez Martínez Luis Felipe

Materia: Estructura de Datos II
Sección: D06 - 2023B
Profesor: Mariscal Lugo Luis Felipe
 Contenido

CAMPO ................................................................................................................................................ 3

REGISTRO............................................................................................................................................. 4

REGISTRO DE LONGITUD FIJA .............................................................................................................. 5

REGISTRO DE LONGITUD VARIABLE..................................................................................................... 6

DELIMITADORES .................................................................................................................................. 7
 CAMPO

En el contexto de programación en C++, un "campo" generalmente se refiere a una variable

miembro dentro de una estructura (struct) o una clase (class). Una estructura o clase es una forma
de definir un nuevo tipo de dato que puede contener múltiples variables con diferentes tipos de
datos. Estas variables dentro de una estructura o clase se llaman "campos".

Por ejemplo, el siguiente código en C++ define una estructura llamada "Persona" con varios
campos:

En este caso, la estructura "Persona" tiene tres campos: "nombre" de tipo std::string, "edad" de
tipo int, y "genero" de tipo char.

Los campos en C++ permiten almacenar y acceder a diferentes piezas de información relacionada
dentro de una estructura o clase, lo que facilita la organización y manipulación de datos en
programas más complejos.
 REGISTRO

Un registro, en programación, es un tipo de dato estructurado formado por la unión de varios

elementos bajo una misma estructura. Estos elementos pueden ser, o bien datos elementales
(entero, real, carácter), o bien otras estructuras de datos.

A cada uno de esos elementos se le llama campo.

Por ejemplo:

Este es un ejemplo de un registro, es una estructura en la cual se tienen varios campos, en este
caso son datos que se tienen de una persona, como su id, nombre, saldo que tiene y su número
telefónico.

Es importante destacar que, en C++, se tiende a usar el término "estructura" en lugar de "registro"
para describir este tipo de agrupación de campos
 REGISTRO DE LONGITUD FIJA

Un "registro de longitud fija" es una estructura de datos en la que cada registro, fila o entrada tiene
un tamaño predefinido y constante en términos de cantidad de bytes. Esto significa que cada
registro ocupa una cantidad fija de espacio en memoria, independientemente de la cantidad de
datos que realmente contenga.

Este concepto es comúnmente utilizado en sistemas de bases de datos y en almacenamiento de

datos en general. En un registro de longitud fija, los campos individuales (atributos o columnas)
dentro de cada registro también tienen un tamaño fijo. Esta organización tiene ventajas en
términos de acceso eficiente y cálculos predecibles, pero puede resultar en un uso ineficiente de
memoria si algunos registros tienen campos que no utilizan todo el espacio asignado.

Por ejemplo, supongamos que tienes un registro de longitud fija para almacenar información de
empleados, y el tamaño total del registro es de 100 bytes. Cada campo dentro del registro, como el
nombre, el salario, la edad, etc., ocupará un número fijo de bytes.

El uso de registros de longitud fija es común cuando se necesita una estructura de datos predecible
y eficiente en términos de acceso. Sin embargo, en sistemas modernos, las bases de datos y
estructuras de datos flexibles son más comunes debido a la variedad de tamaños y tipos de datos
que deben manejarse.

En contraste, un "registro de longitud variable" permitiría tamaños de registros y campos variables,

lo que brinda más flexibilidad, pero puede requerir más complejidad en la administración y el
acceso a los datos.
 REGISTRO DE LONGITUD VARIABLE

Un "registro de longitud variable" es una estructura de datos en la que cada registro, fila o entrada
puede tener un tamaño diferente en términos de cantidad de bytes. A diferencia de un registro de
longitud fija, en el que todos los registros tienen el mismo tamaño, en un registro de longitud
variable, los registros pueden variar en tamaño dependiendo de la cantidad de datos que
contengan.

Este concepto es comúnmente utilizado en sistemas de bases de datos y en almacenamiento de

datos cuando los registros pueden contener cantidades variables de información. En un registro de
longitud variable, los campos individuales dentro de cada registro también pueden tener tamaños
variables.

Por ejemplo, en un sistema de gestión de bibliotecas, un registro de longitud variable podría usarse
para almacenar información sobre libros. Algunos libros pueden tener títulos más largos, autores
con nombres más largos y más información que otros, lo que haría que sus registros fueran más
largos que los registros de libros con menos detalles.

En C++, puedes implementar registros de longitud variable utilizando estructuras (clases) y, en

algunos casos, contenedores de datos dinámicos como vector o listas enlazadas para manejar la
variabilidad del tamaño. Cada registro podría ser un objeto que contiene campos (miembros) con
tipos de datos variados y tamaños que se ajustan a las necesidades específicas de los datos que
estás almacenando.

Es importante destacar que, a diferencia de un registro de longitud fija, el manejo de registros de

longitud variable puede ser más complejo debido a la necesidad de administrar dinámicamente la
memoria y los tamaños de los registros.
 DELIMITADORES

En C++, cuando hablamos de delimitadores en el contexto de archivos, nos referimos a caracteres

o secuencias de caracteres que se utilizan para separar o marcar diferentes partes de información
dentro de un archivo. Estos delimitadores son útiles para estructurar los datos almacenados en el
archivo de manera que puedan ser leídos y procesados correctamente.

Los delimitadores en archivos se utilizan para indicar dónde comienzan y terminan ciertas
secciones de datos, registros o campos. Aquí hay algunos ejemplos comunes de delimitadores en
archivos en C++:

Delimitadores de Campo: En archivos que almacenan datos tabulares, como archivos CSV (Comma-
Separated Values), los delimitadores de campo separan los valores de diferentes columnas. Por
ejemplo, en un archivo CSV, la coma, se usa como delimitador de campo para separar los valores
de diferentes columnas.

Delimitadores de Registro: En archivos que almacenan registros o entradas, como una base de
datos simple en un archivo de texto, los delimitadores de registro indican dónde comienza y
termina cada entrada. Puede ser un carácter de nueva línea (\n) o cualquier otro carácter especial
que elijas para indicar el final de un registro.

Delimitadores Personalizados: En algunos casos, puedes definir tus propios delimitadores según las
necesidades de tus datos. Por ejemplo, si estás almacenando una estructura de datos
personalizada en un archivo, puedes elegir delimitadores especiales para separar diferentes partes
de la estructura.

Delimitadores en Formatos Binarios: En archivos binarios, donde los datos se almacenan en su

representación de bytes, los delimitadores pueden ser secuencias de bytes especiales que indican
ciertas marcas o secciones dentro del archivo.

Es importante destacar que el uso de delimitadores en archivos requiere que tanto el escritor
como el lector del archivo estén sincronizados en cuanto a cuáles delimitadores se utilizan y cómo
se interpretan. Siempre es recomendable elegir delimitadores que sean poco probables de
aparecer en los propios datos para evitar confusiones en el procesamiento posterior.
 Bibliografía

BillWagner. (s/f). Campos: Guía de programación. Recuperado el 24 de agosto de 2023, de

Microsoft.com website: https://learn.microsoft.com/es-

es/dotnet/csharp/programming-guide/classes-and-structs/fields

Cruz, M. (2012, octubre 21). Registros en C++ / Uso de struct en C++. Recuperado el 24 de

agosto de 2023, de Martincruz.me website:

https://blog.martincruz.me/2012/10/registros-en-c-uso-de-struct-en-c_4493.html

IBM Documentation. (2023, abril 11). Recuperado el 24 de agosto de 2023, de Ibm.com

website: https://www.ibm.com/docs/es/i/7.5?topic=ddm-variable-length-records

IBM Documentation. (s/f). Recuperado el 24 de agosto de 2023, de Ibm.com website:

https://www.ibm.com/docs/es/developer-for-zos/9.1.1?topic=ssq2r2-9-1-1-com-

ibm-etools-pl1-win-doc-topics-amthdodelmt-html