Dev - C++ - Othello - algunas lineas

   
Vista:

Othello - algunas lineas

Publicado por Oscar A (2 intervenciones) el 15/12/2009 17:23:08
Hola compas.

Miren compas, estoy, como el titulo lo indica (o no lo indica XD), haciendo un othello y me estoy ayudando con unos codigos que consegui x alli para entender la logica que este debe llevar,,, pues bien mi duda va por algunas lineas que no logro entender y no logro encontrar nada x ahi sobre ellas pues son muy implicitas.

int variable;
__________________________________
if ( variable & 1 ) -> ??
{ }
__________________________________
variable >>= 1; -> ??
__________________________________
int** tabla; -> ?? Me imagino que esto es una especie de matrix.
__________________________________
tabla = (int**)malloc( sizeof(int*) * n ); -> ??
__________________________________


Gracias x el espacio.

Salu2.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

RE:Othello - algunas lineas

Publicado por powersgame (7 intervenciones) el 16/12/2009 02:17:15
Hola.

if ( variable & 1 )
{}

Supongo que te refieres a la expresión "variable & 1" , pues es muy básico que la sentencia if condiciona el flujo de ejecución del código, de forma que si la expresión entre paréntesis es verdadera se ejecutará lo que se encuentra en el bloque entre llaves (Una expresion es verdadera si su valor es distinto de 0 y falsa si es 0).

El operador &, representa la operación lógica AND bit a bit. Tenga en cuenta que realmente la variable contiene un valor binario. Suponga que variable como entero que es contiene el valor decimal 7 que en binario es 111, la expresión "variable & 1" equivale a la opreacion logica 111 AND 001 que es igual a 001 por tanto la expresión se considera verdadera. La expresión será verdadera cuando variable sea un número que en formato binario termine en 1 (número impares) y falsa cuando termine en 0 (número pares)

variable >>= 1;

Desplazamiento hacia la derecha con asignación. El operador >> representa el desplazamiento binario hacia la derecha, es decir, desplaza el valor binario del primer operando tantas posiciones como indique el segundo operando. El signo igual representa la asignación despues de evaluar la expresion. Así la expresión
"variable >>= 1", si variable contiene el valor 11 (1011), se evalua de la siguiente forma. se calcula 1011 >> 1 que es 0101(se ha desplaza cada bit un lugar a la derecha y se rellena con 0, siempre que el valor sea positivo), este resultado se guardará en variable.

El operador de desplazamiento binario equivale a la división entera entre potencias de 2, es decir, "a >> b" equivale a la parte entera de "a / 2^b". Por ejemplo 11 >> 2 es equivalente la parte entera de 11/4 que es 2.

También es muy común el operador de desplazamiento a la izquierda <<, que análogamente equivale a la multiplicacion por potencias de 2.

int** tabla;

Declara un puntero a puntero a entero. Esta sentencia realmente no declara una matriz de enteros como supones sino que más bien es una referencia. Para enteder esto debe saber como se almacena los datos en memoria y conceptos básicos de punteros. Como no se si lo dominas te lo explico por encima y a lo rápido. Un puntero referencia un lugar en memoria (su valor es una dirección de memoria). Un vector de enteros no es más que una serie de posiciones de memoria consecutivas que guardan valores enteros. Asi podemos referenciar al vector con un puntero a el primer elemento. Suponga la variable "int vector [13]" y "int* pvect", si realizmos "pvect = vector" pvect apuntará al primer elemento de vector, es decir, *pvect == vector [0]. Como puede ver pvect no representa el vector sino una referencia a él. Una matriz es un vector de punteros donde los punteros apuntan a vectores. Es decir se trata una matriz como un vector de vectores. Por tanto int** tabla es un puntero que apuntará a un puntero que apunte a un entero. Así se podría apuntar al primer elemento de un vector de punteros a enteros donde cada puntero apunte al primer elemento de un vector de enteros. No se puede olvidar que int** representa una referencia a memoria y no el valor en si.

tabla = (int**)malloc( sizeof(int*) * n );

Para entender esta línea te debe quedar claro los conceptos básicos de punteros y conceptos como la memoria dinámica. Al declarase una varible de la forma "int a" a la hora de ejecutar el programa se reservara memoria para un entero a, si la declaración es "int a [9]" se reservará memoria para 9 enteros consecutivos que formarán el valor del vector "a". Pero ¿Qué pasa si a la hora de programar no sabemos el número de elementos que tendrá un vector?¿Qué pasa si es durante la ejecución cuando se decide cuantos elementos tendrá? Pues para ello se utiliza la memoria dinámica. Es decir en la memoria dinámica se reserva espacio en tiempo de ejecución. Para reservar memoria dinámica se utiliza la función malloc o calloc, ambas disponibles incluyendo la cabecera stdlib.h. La función malloc reserva memoria dinámica y devuelve un puntero sin formato a la primera posición de la zona reservada. La función sizeof devuelve el tamaño que ocupa un tipo de dato, así malloc (sizeof(int*) * n) devuelve un puntero a la primera posicion de memoria de una zona que ocupa lo que ocupa un puntero a entero por n, supongamos n = 8, pues devolvería un puntero a una zona de memoria donde caben 8 punteros a enteros. El puntero devuelto por malloc no tiene formato por lo que se le da con (int**) indicando que es un puntero a puntero de enteros. Con esto hemos reservado memoria para 8 punteros a enteros, suponga que quiere una matriz de 8 filas por 3 columnas, entonces tendremos que hacer tabla = (int**)malloc( sizeof(int*) * 8 ) reservando así memoria para 8 punteros a enteris y luego tabla [0] = (int*)malloc( sizeof(int) * 3 ), ..., tabla [7] = (int*)malloc( sizeof(int) * 3 ), reservando asi para tres enteros para cada puntero del vector. Una forma de declarar una matriz de NxM podria ser:

int** matriz; //Solo es una referencia que inicial mente no apunta a datos coerentes
int cont = 0;
int n, m;
... // se le da un valor a m y n, por ejemplo pidiéndoselo al usuario con scanf
matriz = (int**)malloc( sizeof(int*) * n ); //Reserva para un vector de n punteros a enteros
while (cont < n){
matriz [cont] = (int*)malloc( sizeof(int) * m ); // Reserva para un vector de m enteros
cont ++;
}

Es importante que tras reservar memoria dinámica y esta deje de utilizarse se libere, para que pueda ser reutilizada, para ello se utiliza la función free()

Espero haberte servido de ayuda.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Othello - algunas lineas

Publicado por Oscar A (2 intervenciones) el 18/12/2009 00:22:49
powersgame, mejor explicado no pudo estar.

Gracias x el tiempo.

Salu2.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar