C y C++

Yo empecé a programar en java; bueno en realidad en visual basic(pero es algo que quiero olvidar) y por eso es obvio que tuviera algunos problemitas con los punteros al pasar a C.

Bueno, segun yo, ya los habia entendido; sin embargo, no fue así, ya que empecé a tener algunas dudas. En fin, segun la definicion de punteros, estos son variables que hacen referencia a una direccion de memoria, pues si es así, entonces yo supuse que si creaba 3 punteros de enteros seguidos, estos apuntarian a direcciones de memoria contiguas.

Me di con la sorpresa de que no, y es que hay dos formas de hacer que un grupo de enteros esten en direcciones contiguas en la memoria, con 4 bytes cada uno(C/C++). En realidad no es algo muy complicado, solo que yo recien me di cuenta de esto. :-D

La primera:

int *x = new int[3];

En la declaracion anterior al querer imprimir las direcciones de cada una de ellas, imprimiran direcciones en hexadecimal contiguas.

La segunda:

int x[] = {1, 2, 3};

Al ser una arreglo aquí si estaran juntas las 3(obvio)

Ahora, que pasaría si hago esto:

int *num[3];

num[0] = (int*)malloc(sizeof(int));
num[1] = (int*)malloc(sizeof(int));
num[2] = (int*)malloc(sizeof(int));

*num[0] = 100;
*num[1] = 200;
*num[2] = 300;

for(int i=0; i<3; i++)
std::cout<<num[i]<<std::endl;

Aquí aunque pareciera que deberian estar las direcciones juntas, no lo estan, puesto a que esto es un arreglo de punteros y por cada puntero hago un malloc() distinto, lo que hace que el sistema operativo asigne la direccion que mejor le parezca a cada uno de ellos.

Bueno, ahora pondre un codigo en C++ ejemplificando lo que dije en este post.

Saludos.

#include <iostream>

using namespace std;

int main()
{

/*Direcciones de memoria separadas, donde el SO considere, porque se separa memoria 3 veces por separado(3     new)*/
int *a = new int;
int *b = new int;
int *c = new int;

cout<<a<<endl;
cout<<b<<endl;
cout<<c<<endl;
/*********************************************************/

cout<<endl;

/*Direccciones de memoria juntas, la direccion varia de 4 en 4 bytes*/
int d[] = {1, 2, 3};

for(int i=0; i<3; i++)
cout<<&d[i]<<endl;
/************************************************************/

cout<<endl;

/*Direccciones de memoria juntas, la direccion varia de 4 en 4 bytes*/
int *e = (int*)(malloc(sizeof(int)*3));

for(int i=0; i<3; i++)
cout<<&e[i]<<endl;
/***********************************************************/

system("pause");
return 0;
}