Temas

Buenas, escribo porque hasta ahora el diseño de la interfaz siempre ha sido el principal "cuello de botella" que tengo al crear una página web. Puedo programar decentemente en PHP, pero el diseño parece sacado de 10 años atrás.

Hace poco leí sobre la existencia de "frameworks" que ayudan a crear la interfaz con mayor facilidad, proporcionando botones, menús, etc. Buscando por ahí me encontré con uno que se llama Bootstrap, que al parecer es bastante bueno.

A primera vista me parece muy interesante y lo voy a probar. De todas maneras, me gustaría conocer la opinión de alguien más. ¿Vale la pena usar un framework? ¿Podría alguien contar de su experiencia?

Saludos,
Wofo.

Buenas,

Escribo porque ya no puedo compilar con MinGW y no he podido arreglarlo. Cada vez que intento compilar un programa, recibo el error:

Código [Seleccionar] Expandir

g++: error: CreateProcess: No such file or directory

Probé usando "g++ source.cpp -v" para que me diera más información. Por supuesto que no entendí nada, pero el resultado fue el siguiente (*le dí espaciado entre líneas para que quede más claro):

Código [Seleccionar] Expandir

Usando especificaciones internas.

COLLECT_GCC=g++

Objetivo: mingw32

Configurado con: ../gcc-4.6.2/configure --enable-languages=c,c++,ada,fortran,objc,obj-c++ --disable-sjlj-exceptions --with-dwarf2 --enable-shared --enable-libgomp --disable-win32-registry --enable-libstdcxx-debug --enable-version-specific-runtime-libs --build=mingw32 --prefix=/mingw

Modelo de hilos: win32

gcc versión 4.6.2 (GCC)

COLLECT_GCC_OPTIONS='-v' '-shared-libgcc' '-mtune=i386' '-march=i386' cc1plus -quiet -v -iprefix c:\documents and settings\wofo\mis documentos\programación\c++\completo\buscaminas\../lib/gcc/mingw32/4.6.2/ main.cpp -quiet -dump base main.cpp -mtune=i386 -march=i386 -auxbase main -version -o C:\DOCUME~1\Wofo\CONFIG~1\Temp\ccUuHOnL.s

g++: error: CreateProcess: No such file or directory

He intentado algunas soluciones que encontré en Stack Overflow y Google, pero nada funciona.

Cosas que he probado sin resultado:
-He reinstalado el MinGW dos veces en directorios distintos.
-Me he preocupado de que MinGW/bin esté incluido en el PATH del sistema.
-Desinstalé CodeBlocks (leí en un blog que podía servir).
-Reinicié windows (es impresionante la cantidad de cosas que se arreglan con este sencillo truco, pero esa vez falló).
-Intenté eliminar la variable de entorno "GCC_EXEC_PREFIX", pero descubrí que no la tengo (así que no era necesario eliminarla).

Dejo información sobre mi sistema que puede ser importante:
-S.O.: Windows XP SP3.
-Arquitectura del procesador: x86.

A ver si alguien tiene alguna idea  

Saludos,
Wofo.

[notebook]

Buenas,

Escribo porque voy a comenzar a estudiar Informática en la universidad y voy a comprar un notebook. Después de mucho investigar y comparar creo que sé más o menos lo que necesito. De todas maneras, aprovecho de preguntar para asegurarme.

Lo que me interesa:
-Programar.
-Navegar por internet, etc.
-Que dure por lo menos 5 años.
-Que no supere el presupuesto máximo (650 euros).

Lo que NO me interesa:
-Jugar.
-Ver películas/series/videos en general.
-Tener una gran resolución de pantalla.

Dadas las condiciones anteriores, creo que el notebook que necesito debe cumplir con las siguientes especificaciones técnicas:
-Procesador: Intel i5 3337U
-Memoria: 8GB
-Video: Intel HD Graphics integrada

Las dudas que tengo son:
-He escuchado que las Intel HD Graphics no se comparan con una tarjeta de video dedicada y que no sirven para jugar juegos muy realistas (cosa que no me importa). ¿Será suficiente para programar y testear juegos no muy potentes, y para diseñar cosas 3D sencillas?
-¿Vale la pena pagar más por un procesador un poco mejor? Por ejemplo, el i5 3230M.
-¿Es necesario 8GB de memoria o con 4GB/6GB está bien?
-Y la pregunta del millón... ¿Qué marca debería elegir? ¿Es importante la marca o basta que las especificaciones técnicas sean las que quiero?

Puedo dar más información si es necesario. No dudeis en preguntar.

Muchas gracias de antemano,
Wofo.

Buenas, escribo porque estoy desarrollando el clásico juego de la víbora y estoy un poco confundido con el enfoque de orientiación a objetos que debo seguir.

Por un lado tengo el objeto Víbora y por el otro Comida. La víbora contiene un array de puntos (con lo que la puedo mostrar en pantalla) y la comida contiene un punto.

El movimiento de la víbora está controlado por el método Víbora::mover(), que funciona perfectamente. El problema es que desde ese método no puedo comprobar si la víbora pasa por encima de una comida (y, por lo tanto, se la come), porque el objeto Comida no está dentro de la clase víbora (está en el main).

Son dos objetos separados, como muestra el ejemplo.

Código (cpp) [Seleccionar] Expandir

int main() {
Vibora vibora;
Comida comida;
}

Alternativas que se me ocurren:
-Comprobar desde el main si la víbora come algo (me da la impresión que es una solución sucia y que debe haber alguna otra mejor).
-Crear el objeto Comida dentro de la clase Víbora (sería como forzar la orientación a objetos ya que no existe relación entre Comida y Víbora).

Ambas alternativas me parecen malas. ¿Alguien tiene una mejor idea?

Espero haberme explicado bien. Si no, decidme y lo intento otra vez.

Muchas gracias,
Wofo.

[Conceptos implementados:-Herencia-Manejo de errores (excepciones)-Uso de la clase vector-Generación de números aleatorios]

Buenas gente, luego de algunos días trabajando en un buscaminas para aprender, les dejo el código para que lo puedan aprovechar.

Lo programé poniendo especial empeño en que fuera orientado a objetos y exclusivamente C++ (intenté no usar nada de C). También escribí muchos comentarios para que quede todo más claro y sea muy fácil de entender.

Espero que a alguien le sirva para aprender. Por lo menos a mí me sirvió bastante.

Una particularidad del programa es que, gracias a que está orientado a objetos, es posible crear una interfaz gráfica sin tener que modificar ni una sola línea de código dentro de las clases.

Conceptos implementados:
-Herencia
-Manejo de errores (excepciones)
-Uso de la clase vector
-Generación de números aleatorios


*Nota: este es un segundo upload con correcciones para mejorar el manejo de excepciones y una mejor orientación a objetos
Programa: Buscaminas
IDE: Ninguna (Notepad++) *Se puede compilar escribiendo g++ main.cpp -o archivo_compilado
Link: http://depositfiles.com/files/z79itfr7f

________

Por si alguien prefiere copiar el código en vez de descargarlo de depositfiles, lo dejo aquí también:
*Es importante guardar los archivos con el mismo nombre, para que funcionen los includes correctamente.

main.cpp

Código (cpp) [Seleccionar] Expandir

#include <iostream> //Necesario para mostrar el contenido por la consola
#include <stdexcept> //Necesario para manejo de errores
#include <cstdlib> //Necesario para rand() en la clase Random_Number
#include <time.h> //Necesario para la clase Random_Number
#include <vector> //Necesario para usar vectores

#include "console_board.cpp"

using namespace std;

int main() {
try {
Console_Board board;
int level = -1;

//Menú principal
cout << "Bienvenido al Buscaminas. Elige el nivel que deseas jugar" << endl
<< "1- Principiante" << endl
<< "2- Intermedio" << endl << endl
<< "Escribe el numero del nivel: ";
cin >> level;

//Creo el nivel
if(level == 2)
board.create(16, 16, 40); //16x16 y 40 minas
else
board.create(9, 9, 10); //9x9 y 10 minas

//Muestro las instrucciones
cout << endl << "--INSTRUCCIONES--";
cout << endl << "Elegir un cuadrado: e x y (ejemplo: e 2 3).";
cout << endl << "Marcar un cuadrado como mina: m x y (ejemplo: m 2 3). " << endl << endl;

system("pause");

//Preparo el game_loop y lo comienzo
bool game_loop = true, victory = false;
int x = 0, y = 0;
char option = '-';
while(game_loop == true && victory == false) {
system("CLS");
board.print();
cout << "Minas restantes: " << board.get_left_mines() << endl;
cout << "Ultima eleccion: " << option << ' ' << x << ", " << y << endl << endl;
cout << "Comando: ";
cin >> option >> x >> y;
/*Por si no introdujo un número limpio el cin. De lo contrario, al introducir un string empieza a correr el while de modo infinito sin volver a preguntar por las coordenadas*/
cin.clear(); cin.ignore(99,'\n');
if(option == 'm')
board.mark_square(x-1, y-1);
else {
board.choose_square(x-1, y-1);
if( board.is_valid(x-1, y-1) && board.square(x-1, y-1).is_mine() ) game_loop = false;
}
if( board.no_squares_left() ) {
board.mark_all_mines();
victory = true;
}
}

//Muestro el tablero por última vez
system("CLS");
board.print();
cout << endl << endl;

if(victory == false)
cout << "Has perdido!";
else
cout << "Felicitaciones! Has ganado!";

cout << endl;

return 0;
}
catch(exception& ex) {
cerr << "Se ha procucido un error: " << ex.what();
return 1;
}
}

board.cpp

Código (cpp) [Seleccionar] Expandir

/* Clase Board.
* Maneja los elementos del juego Buscaminas. Consiste en un tablero (Board en inglés)
* que tiene cuadrados (Squares).
*
*
* Includes necesarios para el funcionamiento de esta clase
*
* #include <iostream>  | Para usar cout
* #include <vector>    | Para usar vector
* #include <stdexcept> | Para manejo de errores */

#include "square.cpp"
#include "random_number.cpp"

class Board {
std::vector< std::vector<Square> > squares;
int width, height;
int left_mines; //Minas que quedan (va descontando cuando el usuario marca una)
int total_mines; //Cantidad de cuadrados que contienen una mina
int total_number_squares; //Cantidad de cuadrados que contienen un número
bool first_choosing;

//Métodos privados
void set_size(int width, int height);
void set_mines(int x, int y);
void set_numbers();
void show_empty_squares(int x, int y);
int count_surrounding_mines(int x, int y);
int shown_squares();

//Métodos públicos
public:
void create(int width, int height, int param_mines);
void choose_square(int x, int y);
void mark_square(int x, int y);
void mark_all_mines();

bool is_valid(int x, int y);
bool no_squares_left();

Square square(int x, int y);
inline int get_width() { return width; }
inline int get_height() { return height; }
inline int get_left_mines() { return left_mines; }
};

void Board::set_size(int param_width, int param_height) {
//Asigna el tamaño al tablero
//Condición: los argumentos deben ser positivos
if(param_width <= 0 || param_height <= 0)
throw std::runtime_error("No puedes crear un tablero con ancho o alto negativos.");

//Método de la clase vector que sirve para inicializarlo. En este caso creo un vector bidimensional con el ancho "param_width" y alto "param_height"
squares.assign(param_width, std::vector<Square>(param_height));

//Guardo el tamaño del tablero en atributos para usarlo más tarde
width = param_width;
height = param_height;
}

void Board::set_mines(int x, int y) {
//Asigna las minas de manera aleatoria a partir del atributo total_mines
//No se pone ninguna mina en el punto x, y
Random_Number random_number = Random_Number();
int x_aux;
int y_aux;

for(int i = 0; i < total_mines;) {
x_aux = random_number.get(0, width-1);
y_aux = random_number.get(0, height-1);

if( !squares[x_aux][y_aux].is_mine() && !squares[x][y].is_mine() ) {
//Si el punto aleatorio no es mina NI el punto entregado como argumento.
squares[x_aux][y_aux].set_mine();
++i;
}
}
}

void Board::set_numbers() {
//Calcula y guarda los números que van en el tablero (y que indican el número de minas que hay alrededor de un cuadrado)
for(int x = 0; x < width; ++x)
for(int y = 0; y < height; ++y) {
//Con estos dos for recorro el tablero completo (se toman todas las combinaciones posibles de x e y)

if( !squares[x][y].is_mine() )
//Si el cuadrado actual es una mina no es necesario asignarle un número.
//Si no es una mina, cuento las minas alrededor y le asigno un número.
//Recordar que x, y son las coordenadas del punto
squares[x][y].set_value( count_surrounding_mines(x, y) );
}
}

void Board::show_empty_squares(int x, int y) {
//Función recursiva que revisa si un cuadrado está vacío y lo muestra. En caso afirmativo revisa los que lo rodean y así sucesivamente.
if(is_valid(x, y) && squares[x][y].get_value() == 0 && squares[x][y].is_hidden()) {
squares[x][y].show();
for(int x_axis = x-1; x_axis <= x+1; ++x_axis)
for(int y_axis = y-1; y_axis <= y+1; ++y_axis) {
//Con estos dos for puedo moverme por los 8 cuadrados circundantes
if(is_valid(x_axis, y_axis) && squares[x_axis][y_axis].get_value() > 0 && !squares[x][y].is_mine())
//Muestro los números que hayan
squares[x_axis][y_axis].show();
show_empty_squares(x_axis, y_axis);
}
}
}

int Board::count_surrounding_mines(int x, int y) {
//Cuenta el número de minas alrededor de un punto
//Condición: el punto debe estar dentro del tabelero
if( !is_valid(x, y) )
throw std::runtime_error("No puedes contar las minas alrededor de un punto que se encuentra fuera del tablero.");

int count = 0;
for(int x_axis = x-1; x_axis <= x+1; ++x_axis)
for(int y_axis = y-1; y_axis <= y+1; ++y_axis)
/*Recorro los 9 puntos, incluyendo el del centro. Pierdo un mínimo de eficiencia, pero el código queda más ordenado. Además, sé que el número del centro no es una mina, por lo que el resultado de la función no cambia*/
if( is_valid(x_axis, y_axis) && squares[x_axis][y_axis].is_mine() )
++count;
return count;
}

int Board::shown_squares() {
int total = 0;

for(int x = 0; x < width; ++x)
for(int y = 0; y < height; ++y)
if( !squares[x][y].is_hidden() && !squares[x][y].is_mine() )
++total;

return total;
}

void Board::create(int param_width, int param_height, int param_mines) {
//Crea el tablero de buscaminas con el tamaño adecuado, asigna las minas y asigna los números.
//Condición: los argumentos deben ser positivos (se comprueba en las otras funciones)
//Condición: la cantidad de minas debe ser positiva (se comprueba aquí)
if(param_mines < 0) throw std::runtime_error("No puedes crear un tablero con un número negativo de minas");
set_size(param_width, param_height); //Asigna al tablero el tamaño adecuado
left_mines = param_mines;
total_mines = param_mines;
total_number_squares = param_width*param_height - param_mines;
first_choosing = true;
}

void Board::choose_square(int x, int y) {
//Hace que el cuadrado elegido muestre su contenido.
//Si el punto x, y está fuera del tablero, la función no hace nada.
if( is_valid(x, y) ) {
if( first_choosing ) {
//Si es la primera vez que se elige un número, pongo las minas excepto en ese lugar y luego proceso la elección.
//De esta manera se hace imposible perder en la primera jugada (es imposible elegir una mina el primer turno)
set_mines(x, y);
set_numbers();
first_choosing = false;
}

if(squares[x][y].get_value() == 0)
//Si el cuadrado elegido está vacío (sin minas ni números)
show_empty_squares(x, y);
else
//Si es un número o una mina
squares[x][y].show();
//En ambos casos, si el cuadrado estaba marcado como mina sumo uno al número de minas restantes
if( squares[x][y].is_marked() ) ++left_mines;
}
}

void Board::mark_square(int x, int y) {
//Marca un cuadrado con un signo para ayudar al usuario a identificar minas.
//La función no hace nada si el punto x, y: está fuera del tablero / no está oculto / ya está marcado
if( is_valid(x, y) && squares[x][y].is_hidden() && !squares[x][y].is_marked() ) {
squares[x][y].mark();
--left_mines;
}
}

void Board::mark_all_mines() {
//Marca todas las minas que no estén marcadas. Así, cuando el usuario gana las puede ver en el tablero.
for(int x = 0; x < width; ++x)
for(int y = 0; y < height; ++y)
if( squares[x][y].is_mine() )
squares[x][y].mark();
left_mines = 0;
}

bool Board::no_squares_left() {
//Calcula el número de cuadrados que están ocultos y no son minas. Devuelve true si no queda ninguno.
return shown_squares() == total_number_squares;
}

bool Board::is_valid(int x, int y) {
//Devuelve true si el punto está dentro del tablero y false si no lo está
return (-1 < x && x < width) && (-1 < y && y < height);
}

Square Board::square(int x, int y) {
//Función que retorna el objeto "Square" dadas las coordenadas x e y.
//Condición: las coordenadas deben apuntar a un "Square" existente.
if( !is_valid(x, y) )
throw std::runtime_error("Board::square no acepta coordenadas de puntos inexistentes.");
return squares[x][y];
}

console_board.cpp

Código (cpp) [Seleccionar] Expandir

/* Clase Console_Board derivada de la clase Console
* Añade el método "print", que permite mostrar el tablero por consola */

#include "board.cpp"

class Console_Board : public Board {
public: void print();
};

void Console_Board::print() {
std::cout << "     ";
for(int i = 0; i < get_width(); ++i) {
if(i < 9)
std::cout << "  " << i+1;
else
std::cout << " " << i+1;
}
std::cout << std::endl << "     ";
for(int i = 0; i < get_width(); ++i)
std::cout << "___";
std::cout << std::endl;

//Imprime los números de la izquierda (coordenadas del eje y)
for(int y = 0; y < get_height(); ++y) {

if(y < 9)
std::cout << "  " << y+1 << " |";
else
std::cout << ' ' << y+1 << " |";

//Imprimo el contenido del tablero. Es necesario que este for esté dentro del anterior.
for(int x = 0; x < get_width(); ++x)
if( square(x, y).is_hidden() ) {
if( square(x, y).is_marked() ) std::cout << "  #";
else std::cout << "  *";
}
else if(square(x, y).get_value() == 0) std::cout << "   ";
else if(square(x, y).get_value() == 9) std::cout << "  X";
else std::cout << "  " << square(x, y).get_value();
std::cout << "\n\n";
}
}

square.cpp

Código (cpp) [Seleccionar] Expandir

/* Clase Square
* El tablero (clase Board) se forma a partir de cuadrados (clase Square).
* Un cuadrado puede contener una mina o un número. */

class Square {
//Atributos
int value;
bool hidden;
bool marked;

//Métodos públicos
public:
Square();
inline int get_value() { return value; }
inline bool is_mine() { return value == 9; }
inline bool is_hidden() { return hidden; }
inline bool is_marked() { return marked; }
inline void set_mine() { value = 9; } //Asigna al cuadrado el valor correspondiente a una mina
inline void set_value(int number) { value = number; }
inline void show() { hidden = false; }
inline void mark() { marked = true; }
};

Square::Square() {
//Esconde el valor del cuadrado (así, todo cuadrado que se crea viene escondido)
hidden = true;
marked = false;
}

random_number.cpp

Código (cpp) [Seleccionar] Expandir

/* Clase Random_number
* Simplifica el cálculo de números "aleatorios"
*
*
* Includes necesarios para que esta clase funcione
* #include <cstdlib> -> Para usar rand()
* #include <time.h> -> Para usar time_t y time() */

class Random_Number {
public:
Random_Number();
int get(int min, int max);
};

Random_Number::Random_Number() {
//Proceso necesario para después generar números (no entiendo exactamente cómo funciona)
time_t seconds; time(&seconds);
srand((unsigned int)seconds);
}

int Random_Number::get(int min, int max) {
//Devuelver un número "aleatorio" entre el rango dado
return rand() % (max - min + 1) + min;
}

Buenas gente, espero que la pregunta no suene demasiado tonta.

Estoy un poco confundido respecto de la importancia de el lenguaje C++, principalmente porque en mi universidad no se enseña. Eso me lleva a pensar que la importancia del lenguaje no es tanta como creía (si fuera importante, lo enseñarían... ¿o no?

Me gustaría saber cuál es la importancia de C++ para la gente que se dedica profesionalmente a la programación, no solo por hobby. Quizá sea más útil recurrir a alguna de las muchísimas alternativas de más alto nivel como Java y C#, con las que (aparentemente) el desarrollo de un programa para una empresa -por poner un ejemplo- podría ser mucho más sencillo sin perder demasiado en rendimiento. ¿Es esto tan así?

¿Cuál es la ventaja de aprender C++? Me imagino que una gran ventaja es que proporciona fundamentos muy sólidos de programación. Pero, ¿hay alguna otra?

¡Anímense a opinar!

Saludos,
Wofo.

Buenas, escribo porque tengo un netbook Dell Inspiron Mini 1012 en el cual instalé Windows 8 para experimentar y ahora que quiero volver al XP que traía de fábrica no lo consigo.

Me parece que el computador tiene una partición oculta en la que hay un respaldo del sistema operativo para dejar todo como si viniera de fábrica. Lo usé varias veces cuando tenía Windows XP, presionando la tecla F11 antes de que partiera Windows. Era una excelente manera de formatear, ya que viene con todos los drivers y el netbook no tiene lector de CD.

El problema es que ahora, con Windows 8, no importa cuántas veces aprete el F11 al encender el computador, simplemente no se inicia la utilidad de restauración del sistema. Lo más que he conseguido es que empiece a sonar el parlante de la tarjeta madre de tanto apretar teclas.

Una posible causa es que tal vez no existía una partición oculta sino que los datos estaban en la misma partición que el XP pero murieron. Creo que esto es improbable.

Otra idea que se me ocurrió es que quizá lo de presionar F11 para lanzar la utilidad de restauración estaba guardado en la partición de XP. Es decir, existe una partición oculta con los datos de restauración, pero no puedo acceder a ella porque el comando para acceder no es reconocido por el computador.

La duda entonces es, ¿cómo acceder a dicha partición?

Muchas gracias,
Wofo.

Buenas, tengo la siguiente duda: ¿es posible usar backtrack en VirtualBox para obtener claves WEP? ¿es lo mismo que instalarlo como S.O. normal?
He buscado en google y he encontrado información contradictoria... Espero que alguien pueda ayudarme.

Saludos,
Wofo.

Buenas, escribo porque hace tiempo tengo el siguiente problema. Al descargar de internet (generalmente de gmail) documentos de Microsoft Office me encuentro con que no puedo abrirlos (como se puede ver en la imagen):


(si no se ve, ir al siguiente link http://fotos.subefotos.com/8805478414321a26e61c5ae905e16d56o.jpg)

La solución a esto es dar click derecho sobre el archivo en cuestión, seleccionar "propiedades" y hacer click en "desbloquear" (como se puede ver en la siguiente imagen):



Me gustaría hacer que no fuera necesario hacer click en ese botón, es decir, que al descargar un documento éste venga automáticamente desbloqueado y se pueda abrir sin tener que realizar una acción adicional.

¿A alguien se le ocurre alguna idea?

Muchas gracias,
Wofo.

Buenas, escribo porque tengo un notebook al cual hace poco le salieron unas rayas verticales de colores con fondo blanco cada vez que lo prendía, sin dejarme ver siquiera cuando se carga la BIOS.

Conecté una pantalla externa a través de un cable RGB y se veía perfectamente, con lo que descarto muchos problemas.
Leí que esto podía deberse al desgaste de un cable que va por dentro del notebook y que une al monitor con el resto del hardware. Pude comprobarlo porque empecé a abrir y a cerrar la pantalla, hasta que -seguramente hice que se moviera el famoso cablecito- pude ver mi escritorio otra vez en la pantalla del notebook.

Hasta el momento no me he atrevido a abrir el notebook, nunca he abierto ninguno y me da miedo destruirlo... Me gustaría saber si alguien, al abrir un notebook, ha visto ese dichoso cable y si es posible cambiarlo sin demasiados conocimientos, idealmente sin tener que soldar nada.

Saludos y muchas gracias de antemano!
Wofo.

Buenas, después de un par de años ausente estoy de nuevo por estos lados...

El problema que tengo es el siguiente: estoy haciendo un sitio web donde necesito usar variables de sesión y por algún motivo desconocido las variables no funcionan bien. Estuve haciendo pruebas y en este momento tengo dos archivos:

index.php

Código (php) [Seleccionar] Expandir


<?php 
session_start();

echo 'Tu id de sesión es: '.session_id().'<br />'; //Imprimo el id de sesión
echo 'Tu nombre es: '.$_session['nombre']; //Imprimo el contenido de la variable de sesión 'nombre'
?>


login.php

Código (php) [Seleccionar] Expandir


<?
session_start();

$_session['nombre'] = 'Wofox'; //Doy a la variable de sesión 'nombre' el valor 'Wofox'

echo 'Tu id de sesión es: '.session_id().'<br />'; //Imprimo la id de sesión, así puedo comprobar si en el index tengo la misma sesión
echo 'Tu nombre es: '.$_session['nombre'].'<br />'; //Imprimo el contenido de la variable de sesión 'nombre'
echo '<a href="index.php">Ir al index</a>'; //Imprimo un link al index

?>


Lo que sucede es lo siguiente:
Entro a login.php y me imprime lo siguiente:

Código [Seleccionar] Expandir


Tu id de sesión es: f5b1fb3d31106d2dbccc9790a133fc64
Tu nombre es: Wofox
Ir al index


Luego entro a index.php y me imprime lo siguiente.

Código [Seleccionar] Expandir


Tu id de sesión es: f5b1fb3d31106d2dbccc9790a133fc64
Tu nombre es:


Como se ve, el session_id es el mismo, por lo tanto lo lógico sería que pudiera acceder a la variable $_session['nombre'] y sin embargo, por alguna razón que desconozco, no puedo.

Estuve leyendo y buscando en google pero no encontré a nadie con el mismo problema...

¿Alguna idea para solucionarlo?

PD: He modificado el post para que se entienda mejor.

Si alguien sabe cómo editar el valor contenido en una dirección hexadecimal me gustaría que me explicara.
Gracias