FUNCION SIZEOF ()

Para reservar memoria se debe de saber exactamente el numero de bytes que ocupa cualquier
estructura de datos. Tal y como se ha comentado con anterioridad, una peculiaridad del lenguaje
c es que estos tamaños pueden variar de una plataforma a otra. Como sabemos, entonces,
cuantos bytes reserva para una tabla de, por ejemplo,10 enteros? El propio lenguaje ofrece la
solución a este problema mediante la función sizeof ().

La función recibe como único parámetro o el nombre de una variable, o el nombre de un tipo
de datos , y devuelve su tamaño en bytes. De esta forma, sizeof (int) devuelve el numero de
bytes que se utilizan para almacenar un entero. La función se puede utilizar también con tipos
de datos estructurados o uniones tal y como se muestra en el siguientes programa.

#include <stdio.h>
#define NAME_LENGTH 10
#define TABLE_SIZE 100
#define UNITS_NUMBER 10

struct unit
{ /* Define a struct with an internal union */
int x;
float y;
double z;
short int a;
long b;
union
{ /* Union with no name because it is internal to the struct */
char name[NAME_LENGTH];
int id;
short int sid;
} identifier;
};

int main(int argc, char *argv[])

{
int table[TABLE_SIZE];
struct unit data[UNITS_NUMBER];

printf("%d\n", sizeof(struct unit)); /* Print size of structure */

printf("%d\n", sizeof(table)); /* Print size of table of ints
*/
printf("%d\n", sizeof(data)); /* Print size of table of
structs */

return 0;
}

Con esta función puedes , por tanto , resolver cualquier duda que tengas sobre el tamaño de
una estructura de datos . basta con escribir un pequeño programa que imprima su tamaño con
sizeof ().
OPERADOR NEW

El operador new sirve para reservar memoria dinámica.

Sintaxis:

[::]new [<emplazamiento>] <tipo> [(<inicialización>)]

[::]new [<emplazamiento>] (<tipo>) [(<inicialización>)]
[::]new [<emplazamiento>] <tipo>[<número_elementos>]
[::]new [<emplazamiento>] (<tipo>)[<número_elementos>]

El operador opcional :: esta relacionado con la sobrecarga de operadores , de momento no lo

usaremos . lo mismo se aplica a emplazamiento.

La inicialización, si aparece , se usara para asignar valores iniciales a la memoria reservada con
new, pero no puede ser usada con arrays.

Las formas tercera y cuarta se usan para reservar memoria de arrays dinámicos. La memoria
reservada con new será valida hasta que se libere con delete o hasta el fin del programa, aunque
es aconsejable liberar siempre la memoria reservada con new usando delete. Se considera una
practica muy sospechosa no hacerlo.

Si la reserva de memoria no tuvo éxito, new devuelve un puntero nulo,NULL.

TIPOS ENUMERADOS

Los tipos enumerados son un mecanismo usado en C y C++ con el objetivo de agrupar de alguna
manera constantes simbólicas. Para definir tipos enumerados se usa la palabra reservada enum.
Ejemplo 1

enum dias { domingo, lunes, martes, miercoles, jueves, viernes, sabado

};

En el ejemplo anterior se define por medio de enum el tipo enumerado dias, en el mismo
ejemplo se debe observar que dentro de la construcción se definen las constantes simbólicas:
domingo, lunes, ... sabado; y que a las mismas el compilador les asignará respectivamente y por
defecto los valores: 0, 1, 2, 3, 4, 5, 6. Es decir, las constantes mencionadas pueden usarse dentro
del programa y este sabrá a que valor hace referencia cada una de las mismas. Por ejemplo, la
instrucción: cout << domingo; desplegará 0 en la pantalla. El siguiente ejemplo muestra como
usar las constantes enumeradas en un ciclo for.

for (int d = domingo; d <= sabado; d++) cout << d;

En el siguiente ejemplo se define por medio de enum el tipo enumerado colores, en el mismo
se debe de observar la elinación del comportamiento por defecto ya que a la primera constante
(gris) se le asigna en forma específica el valor de 7, de tal manera que la siguiente constante
(grisoscuro) tendrá un valor igual a 8 y la constante amarillo será igual a 14.

Ejemplo 2
enum colores { gris = 7, grisoscuro, amarillo = 14 };

TIPOS DERIVADOS
Aparte de los tipos básicos y sus variantes, C++ soporta otros tipos de naturaleza compleja que
derivan de aquellos. Dicho en otras palabras: C++ permite al usuario construir otros tipos a
partir de los básicos. De estos "nuevos" tipos, los de nivel de abstracción más alto son
las clases incluyendo sus formas particulares (estructuras y uniones); también pueden
crearse campos de bits; matrices y una familia de tipos muy importante: los punteros. Hay
punteros a cada uno de los demás tipos: a carácter, a entero, a estructura, a función, a puntero,
etc.

Los tipos derivados se construyen con palabras clave: class, struct, unión u operadores
especiales como los siguientes:
 * puntero a
 *const puntero constante a
 & referencia a
 [] array[1] de
 () retorno de función

Ejemplos: suponiendo que tipoX un tipo básico o variante pueden declararse tipos derivados tal
como se muestra:
tipoX t; // t es un objeto de tipo tipoX
tipoX arr[10]; // arr es una matriz de diez
elementos tipoX
tipoX *ptr; // ptr es un puntero a tipoX
tipoX &ref=t; // ref es una referencia a tipoX
tipoX func(void); // func devuelve un valor tipoX (no
acepta parámetros)
void func(tipoX t); // func1 acepta un
parámetro t tipoX (no devuelve nada)
struct st {tipoX t1; tipoX t2}; // la estructura st alberga dos tipoX

TIPOS COMPUESTOS

En C, C++ en orden de crear nuevas estructuras se emplean la palabras

reservadas struct, union y class.

struct: esta orden se emplea para agrupar variables de tipos iguales o diferentes en un solo
registro, con la misma se pueden crear estructuras anónimas, estructuras con nombre, y un tipo
especial de estructura conocida como bit-fields ( banderas o campos de bits ).

union: una union es similar a una struct, salvo que en una estructura creada con union los
campos o variables comparten una dirección de almacenamiento común.

class: una clase es una estructura en donde se agrupan variables y funciones, la misma es usada
en Programación Orientada al Objeto. Las clases no son soportadas por el C estándar.
Sintaxis general: struct

struct [ <nombre tipo de estructura > ] {

[ <tipo> <nombre-variable[, nombre-variable, ...]> ] ;
[ <tipo> <nombre-variable[, nombre-variable, ...]> ] ;
...
} [ <variables de estructura> ] ;

struct: Sintaxis ( variación uno, estructura anónima )

De acuerdo con la sintaxis general de la orden struct es posible crear estructuras de datos
anónimas. Solamente hay que tener en cuenta que en una declaración anónima se debe definir
al menos una variable al final de la declaración. Por ejemplo, con el siguiente fragmento de
código:

struct { int a, b; } p1;

se declara y define la variable estructurada p1, misma que se compone por los miembros a y b;
ambos del tipo int. Ahora bien, la sintaxis mostrada arriba no es tan común ni conveniente, ya
que con la misma solamente se esta creando una variable estructurada pero no un nuevo tipo.
Es decir, si desearamos tener otra variable que tuviera las mismas caracteristicas que posee la
variable p1, necesitariamos escribir exactamente la misma instrucción, salvo que cambiando el
nombre de la variable. Por ejemplo:

struct { int a, b; } p2;

Por supuesto, en una misma línea de instrucción podemos definir más de una variable.
Ejemplo:

struct { int a, b; } p1, p2;

Entonces, para crear nuevos tipos con struct deberemos de modificar la sintaxis mostrada en
los ejemplos anteriores.

Sintaxis: struct ( variación dos, estructura con nombre )

Observe que, la sintaxis para declarar estructuras con nombre es bastante parecida a la sintaxis
para declarar estructuras anónimas; salvo que en una declaración de estructura con nombre se
debe especificar el nombre deseado para la misma. Además, en una declaración de estructura
con nombre la o las variables definidas al final de la misma son opcionales.

Ejemplos:

struct pareja { int a, b; } p1;

En el fragmento de código anterior se declara la estructura identificada como pareja, misma que
se compone de los miembros a y b, ambos de tipo int. En el mismo ejemplo, se define la variable
p1; la cual es una variable estructurada de tipo pareja.

Una vez que una estructura con nombre ha sido creada, la misma puede ser usada para declarar
cualquier número de variables. Por ejemplo, en el siguiente fragmento de código se crea la
estructura tiempo compuesta por los miembros hora, minuto y segundo; todos del tipo int. En
el mismo ejemplo, se declaran las variables t1 y t2.

/* declaración de estructura tiempo */

struct tiempo { int hora, minuto, segundo; };

/* declaración de variables de tipo tiempo */

struct tiempo t1, t2;

Nota: en C++ puede obviarse la palabra struct a la hora de declarar variables. Así, en C++ la línea
de instrucción struct tiempo t1, t2; ( del ejemplo anterior) puede escribirse como: tiempo t1,
t2.