Administración de memoria

ADMINISTRACIÓN DE MEMORIA

 Direcciones de Memoria:
 Posición en la que se almacena una variable en memoria.

 Estructura de la memoria:
 Al definir una variable se le asocian 0x4fffd34
tres atributos: el nombre, el tipo y n 54
la dirección de memoria. int

 Al valor de una variable se accede por el nombre.

 Printf(“%d”,n); //54
 A la dirección de la variable se accede por medio del
operador de dirección &.
 Ejemplo: printf(“%p”,&n); //0x4fffd34
 ADMINISTRACIÓN DE MEMORIA

• Puntero: Variable que almacena una dirección de memoria.

0x4fffd30
p 0x4fffd34
0x4fffd34
n 54
int
#include <stdio.h>
Int main(){
int n=54;
Int *p=&n;
printf(“n= %d, &n=%p, p=%p”, n, &n, p);
printf(“&p= %p ”,&p);
}
 ADMINISTRACIÓN DE MEMORIA

• Operadores de Punteros:
• Operador de Dirección (&): Operador # include <stdio.h>
unario que devuelve la dirección de su
operando. void main(){
char c;
char * ptrC;
• Operador de Indirección u operador
de desreferencia (*): Devuelve el valor ptrC=&c;
del objeto al que apunta su operando (un
apuntador). for (c='A';c<='z';c++)
printf("%c",*ptrC);

}
 ADMINISTRACIÓN DE MEMORIA

 Declaración de Punteros:

 Sintaxis: <tipo_dato_apuntado> * <identificador_puntero>

 Eloperador * en la declaración de una variable indica que esta

almacenará una dirección de memoria.

 Ejemplos:
 int *ptr1;
 long * ptr2;
 Char *ptr3;
 ADMINISTRACIÓN DE MEMORIA
 Inicialización de punteros:
Se le asigna una dirección de memoria utilizando el operador &.
Ejemplo: &i //indica se asigna la dirección de la variable i

 Inicialización estática:
 Se define una variable y luego se le asigna la dirección de memoria
a un puntero. Ejemplo:
Int i;
Int *p;
p=&i;
 Asignar un valor a la dirección de memoria:
*p=50;
 ADMINISTRACIÓN DE MEMORIA

 Inicialización dinámica:
 Asignación dinámica de memoria, utilizando funciones de
asignación como: malloc(), callorc(), realloc(), free().
 ADMINISTRACIÓN DE MEMORIA

 Punteros y verificación de tipos:

 C requiere que las variables puntero direccionen variables del
mismo tipo de dato que está ligado a los punteros en sus
declaraciones.

float *ptr;
char c;
c=&ptr; //No es válido
 ADMINISTRACIÓN DE MEMORIA
 Uso de Operadores & y *:
#include <stdio.h>

int main()
{
int a; /* a es un entero */
int *ptrA; /* ptrA es un apuntador a un entero */

a = 7;
ptrA = &a; /* ptrA toma la dirección de a */

printf("La direccion de a es %p"

"\nEl valor de ptrA es %p"
"\nLa direccion de ptrA es %p", &a, ptrA, &ptrA );

printf("\n\nEl valor de a es %d"

"\nEl valor de *ptrA es %d", a, *ptrA );

printf("\n\nMuestra de que * y & son complementos "

"uno del otro\n&*ptrA = %p"
"\n*&ptrA = %p\n", &*ptrA, *&ptrA );

return 0; /* indica terminación exitosa */

}
 ADMINISTRACIÓN DE MEMORIA

 Operador sizeof:
Operador unario que permite determinar el tamaño en bytes de un
arreglo o de cualquier otro tipo de dato durante la compilación del
programa.

 Ejemplo:
 Sizeof(char); //1
 Sizeof(int); //4

 Sizeof(double); //8

 Tipo size_t: es un tipo definido por el C estándar que representa el

valor que devuelve el operador sizeof.
 ADMINISTRACIÓN DE MEMORIA

 Ejemplo:
/* Cuando el operador sizeof se utiliza en un nombre de arreglo, éste devuelve el
número de bytes en el arreglo. */
#include <stdio.h>

size_t obtieneTamano( float *ptr ); /* prototipo */

int main()
{
float arreglo[ 20 ]; /* crea arreglo */

printf( "El número de bytes en el arreglo es %d"

"\nEl número de bytes devueltos por obtieneTamano es %d\n",
sizeof( arreglo ), obtieneTamano( arreglo ) );

return 0; /* indica terminación exitosa */

} /* fin de main */

/* devuelve el tamaño de ptr */

size_t obtieneTamano( float *ptr )
{ return sizeof( ptr ); }
 ADMINISTRACIÓN DE MEMORIA

 Determinar tamaño de un arreglo usando Operador sizeof:

double real[ 22 ]; //¿Cuantos bytes contiene el arreglo?

 Expresión para determinar el número de elementos en el

arreglo:
 sizeof( real ) / sizeof( double )

La expresión determina el número de bytes del arreglo

real y lo divide entre el número de bytes utilizados en
memoria para almacenar un valor double.
 ADMINISTRACIÓN DE MEMORIA

 Expresiones con apuntadores y aritmética de apuntadores

 Operaciones con los apuntadores:
 Incrementar(++).
 Decrementar(--).
 Sumar un entero(+ o +=).
 Restar un entero (- o -=)
 ADMINISTRACIÓN DE MEMORIA

 Expresiones con apuntadores y aritmética de apuntadores

 Ejemplo:
int v[ 5 ];
int *ptrV;
//inicializarse para que apunte al
//arreglo v con cualquiera de
//las instrucciones
ptrV = v;
ptrV = &v[ 0 ];
ptrV += 2; // 3008 (3000 + 2 * 4)
ptrV -= 4; //asumiendo que ptrV está en 3016, al ejecutar se ubica en 3000
ptrV++;
• Cuando se suma o se resta un entero o a un apuntador, el
ptrV++; apuntador no aumenta o disminuye por dicho entero, sino
por el número de veces del tamaño del objeto al que hace
referencia el apuntador.
• El número de bytes depende del tipo de datos del objeto.
 ADMINISTRACIÓN DE MEMORIA

 Apuntadores y arreglos
 Ejemplo:

Int b[ 5 ] ;
Int *ptrB;
ptrB = b; //ptrB = &b[ 0 ];

 Notación apuntador/desplazamiento: Cuando el apuntador apunta hacia el

principio de un arreglo, el desplazamiento indica a cuál elemento del arreglo se debe
hacer referencia, y el valor de desplazamiento es idéntico al subíndice del arreglo.
 *( ptrB + 3 ) //referencia al elemento b[ 3 ] del arreglo mediante la expresión con
apuntadores. Son necesarios los paréntesis porque la precedencia de * es mas alta
que la de +. Sin paréntesis se suma 3 a b[0]
 ptrB + 3 //referencia a la dirección de un elemento del arreglo &b[ 3 ] mediante
expresión con apuntadores
 *( b + 3 ) //el arreglo mismo puede tomarse como apuntador y usarse en la
aritmética de apuntadores. Referencia al objeto b[3]
 ADMINISTRACIÓN DE MEMORIA

 Apuntadores y arreglos
 Notación apuntador/subíndice.

 ptrB[ 1 ]//Asignación de subíndices a los apuntadores como a los

arreglos. Referencia al elemento b[ 1 ].
 ADMINISTRACIÓN DE MEMORIA

/*Uso de las notaciones de subíndices y de apuntadores con arreglos */

#include <stdio.h>
int main()
{
int b[] = { 10, 20, 30, 40 }; /* inicializa el arreglo b */
int *ptrB = b; /* establece ptrB para que apunte el arreglo b */
int i; /* contador */
int desplazamiento; /* contador */
 ADMINISTRACIÓN DE MEMORIA

/* muestra el arreglo b con la notación de subíndices */

printf( "Arreglo b impreso con:\nNotacion de subindices de arreglos\n" );

/* ciclo a través del arreglo b*/

for ( i = 0; i < 4; i++ ) {
printf( "b[ %d ] = %d\n", i, b[ i ] );
} /* fin de for */
 ADMINISTRACIÓN DE MEMORIA

/* muestra el arreglo b mediante el uso del nombre del arreglo y

notación apuntador/desplazamiento */

printf( "\nNotación apuntador/desplazamiento donde\n"

"el apuntador es el nombre del arreglo\n" );

/* ciclo a través del arreglo b */

for ( desplazamiento = 0; desplazamiento < 4; desplazamiento++ ) {
printf( "*( b + %d ) = %d\n", desplazamiento, *( b + desplazamiento ) );
} /* fin de for */
 ADMINISTRACIÓN DE MEMORIA

/* muestra el arreglo b mediante el uso de ptrB y notación de subíndices

de arreglos */
printf( "\nNotacion de subindices de arreglos\n" );

/* ciclo a través del arreglo b */

for ( i = 0; i < 4; i++ ) {
printf( "ptrB[ %d ] = %d\n", i, ptrB[ i ] );
} /* fin de for */
 ADMINISTRACIÓN DE MEMORIA

/* muestra el arreglo b mediante el uso de ptrB y notación de

apuntador/desplazamiento */
printf( "\nNotación apuntador desplazamiento\n" );

/* ciclo a través del arreglo b */

for ( desplazamiento = 0; desplazamiento < 4; desplazamiento++ ) {
printf( "*( ptrB + %d ) = %d\n", desplazamiento, *( ptrB +
desplazamiento ) );
} /* fin de for */

return 0; /* indica terminación exitosa */

} /* fin de main */