Heap:

En C
 Sección del Memory Layout
Malloc ->Reserva
 No es gestionado automáticamente
Calloc ->Reserva
 El programador interactúa mediante:
Realloc ->Re-Asigna
 Reservación de Memoria.(Allocate)
Free ->Libera
 Liberación de Memoria.(Deallocate/Free)
 Re-asignación de memoria.(Resize)

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

int *age = malloc(sizeof(int));
*age =30;
double *salary = malloc(sizeof(double));
*salary = 12345.67;
double *myList = malloc(3 * sizeof(double));
myList[0] = 1.2;
myList[1] = 2.3;
myList[2] = 3.4;
double*twiceSalary = multiplyByTwo(salary);
printf(“double your salary is %.3f \n”, *twiceSalary);
free(age);
free(salary);
free(myList);
free(twiceSalary);
return 0;
}

Cuando Usar Heap:

 Necesita asignar grandes bloque de memoria (arreglos grandes/estructuras).
 Necesita mantener las variables por largo tiempo.
 Necesita crear estructuras que crecen dinámicamente.

Cuando Usar Stack:

 Necesita variables pequeñas de tamaño fijo.
 Saber que las variables no van a crecer dinámicamente.
 Necesita que las variables solo perduren en el scope que está siendo usado.

Heap Stack or local memory

√ -Tiempo de Vida
-Tamaño
-Copias Locales

X -Más trabajo
-Mayor cantidad de errores
-Tiempo de Vida
-Restricción de comunicación
  Permiten manipular la memoria.
 Cuando declara una variable se asigna memoria a esa variable.
 No almacena directamente el valor, lo apunta o referencia.
 Un puntero almacena una referencia a otro valor.

Un puntero en C

-Es un tipo especial de dato:

int *age;
double *age;
char *age
<static> *;
void *;

Un puntero es usado para interactúa con variables en el Heap pero igual puede servir con el Stack.
& (Ampersand): Asigna un valor a un puntero (Operador de referencia).
* : Obtiene el valor de un puntero.

Valor de Default de un puntero? R/ “Bad value” ó una dirección random.

Desreferenciar un puntero a NULL causa un error en tiempo de ejecución.

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

int data = 55;
int * dataPtr = &data;
prinf(data);
prinf(dataPtr); R/
prinf(*dataPtr); 1) 55
return; 2) 0x000A
} 3) 55

Sharing:
- Tener más de un puntero a un mismo espacio de memoria.

Counter 5
Counter_1 0X000A
Counter_2 0X000A
Shallow Copy Deep Copy
Copia la referencia Copia la referencia
pero no el dato. y también el dato.

counterPtr 0x00A 5
counterPtr 0x00A 5
counterPtr_2 0x00B 5
counterPtr_2 0x00B

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

int value = 5;
int *pointer = & value;
Shalloc Copy
int *pointer2;
pointer2 = pointer;
pointer2= malloc(sizeof(int));
*pointer2= *pointer; Deep Copy
return;
}

Arreglos
0x900 vec[0]
0x901 vec[1]
0x902 vec[2]
Int vec[5] 0x903 vec[3]
0x904 vec[4]
0x905
0x906

Referencias:
-similar a punteros
-punteros usados en contextos de C/C++ y referencia en otros lenguajes
-usado en el contexto de paso de parámetros
C++ también permite referencias:

Ejemplo:

int main(){ Operación implícita (&)

Un alias para int temp=25; para obtener la dirección
el temp int &reference=temp;
printf(reference); Operación implícita (*)
return; para obtener el valor
} apuntado

Paso de parámetros C/C++

 Paso de parámetro por valor:
-El que llama no ve los cambios realizados por el que recibe el llamado.
-El que recibe el llamado recibe una copia idéntica del parámetro.

void setvar (int x){

int x=8;
}
void test(){
int x=10;
setvar(x);
printf(“Value %d\n”,x);
}

 Paso de parámetro por referencia:

-El que recibe el llamado recibe una referencia o puntero del parámetro.
-El que llama ve los cambios realizados por el que recibe el llamado.

void setvar (int x){

int *x=8;
}
void test(){
int x=10;
setvar(&x);
printf(“Value %d\n”,x);
}
Uso del Heap en C/C++
C -> malloc y free
C++ -> new y delete

void* malloc(usigned long size)

- Recibe un entero que indica cuentos bytes necesita reservar.

- Devuelve un puntero al espacio reservado o NULL si no logró hacer la asignación.

void free(void* heapPtr)

- Recibe un puntero a un espacio reservado en el heap y lo libera(Deallocate)

En java
public void javaShallow (){
Foo a = new Foo();
Foo b = new Foo();
a=b;
a.Bar();
}

Menos Errores <-> Más lento

Garbage Collector:
Posee 2 Fases:
1) Fase de marcado.
2) Fase de liberación.

Endianess
-Littler endian => (el byte menos significativo va al inicio de la secuencia) [1]
-Big endian => (el byte menos significativo va al final de la secuencia) [2]

Significativo
90 AB 12 CD
90 AB 12 CD [1]

CD 12 AB 90 [2]