Una Macro

[SrDurden]

                                Exactamente, que es una macro?

Una función pero muy simple?
No acabo de entederlo..

Que hace exactamente esta macro? Y como lo hace?

Código [Seleccionar] Expand

#define KEYSTATE(n) ((GetAsyncKeyState(n) & 0x8000) ? TRUE: FALSE)

En teoría te dice si se está pulsando una tecla..

Esto no sería lo mismo que hacer algo así como:

Código [Seleccionar] Expand



bool KEYSTATE(int? n)

{

  if (GetAsyncKeyState(n) & 0x8000) return true;

  else return false;

}



Y por cierto, que clase de parametro es n? se pasa por valor o por referencia? Supongo que por valor.. y pq hace un AND con 0x8000?




Y esta otra macro?:

Código [Seleccionar] Expand



#define INIT_DXSTRUCT(dxs) { ZeroMemory(&dxs, sizeof(dxs)); dds.dwSize = sizeof(dxs); }



En teoría inicializa una estructura de DirectX a cero.. Pero como? que tipo de parametros le entran?
Supongo que las llaves están ahí pq ejecuta varias instrucciones, si no se podría poner todo en una misma linea, no?
Como sabe una macro si ha de devolver algo o no?
Pq en este caso no devuelve nada..

Siento el coñazo, muchas gracias,

SrDurden 8)                                

[deadLock++]

                                A lo que te refieres son a Macros del preprocesador. El preprocesador realiza una pasada por tú código justo antes de entrar en proceso de compilación por lo tanto esas "funciones" son en realidad código que se pega en donde realizas las llamadas, por lo tanto es mucho mas eficiente (ya que realmente no existe una llamada a función).

Por otro lado tienen una contra, el preprocesador no "entiende" código C/C++ simplemente suplanta a lo bobo lo que encuentra y es por eso que no existe el "tipo de dato" y las "llamadas" son no seguras.

En C++ existen las funciones inline que hacen algo parecido pero a nivel compilador, por lo tanto son funciones reales (desde el punto de vista del código fuente) con tipos de datos, retorno, etc, y también se suplanta el código en lugar de realizar dicha llamada, por lo que es muy eficiente también.

En el libro "Thinking in C++" (http://www.mindview.net/Books/TICPP/Thinki...ingInCPP2e.html) y "Effective C++" hace una comparación entre macros y funciones inline.                                

[Storm]

                                Una macro se sustituye en el lugar donde la llames por la definicion de la misma o dicho de otro modo: Donde pongas KEYSTATE(1) pues el compilador pondra ((GetAsyncKeyState(n) & 0x8000) ? TRUE: FALSE). La ventaja de usar esto en vez de funciones esta en k no realizas llamadas a ninguna de esta , con el ahorro en velocidad k conlleva (k es minimo pero macro a macro...), y suelen tener una gramatica mas flexible.
Sin embargo no crees macros demasiado estensas ya k en cada lugar k escribas por ejemplo KEYSTATE sera remplazado por todo el macro con el aumento de tamaño innecesario k conlleva.

Espero haberte ayudado aunk no se si me explico bien, pero para cualquier cosa pregunta.

Saludos                                

[Grugnorr]

                                Las macros conllevan la aparición frecuente de bugs, como si llamas a un macro con (Variable++) y cosas de ese estilo.

Evita las macros siempre que puedas, yo sólo las uso cuando tengo que usar otras macros como __LINE__, __FILE__ ..... que no hay forma de usar sin usar macros.


A las preguntas iniciales:

-Un macro es una sustitución literal, más o menos como una función, pero no sabe nada de tipos ni demás cosas de C++.

-Los "parámetros" no tienen tipo, es un copy-paste.

- La macro INIT_DXSTRUCT contiene un código de inicialización que repetirás muchas veces, así que la pone una vez. Las llaves son para poner varias instrucciones.

-Que yo recuerde en una macro tienes que poner todo el código en una linea o usar  para romper la linea....

-Los macros no devuelven nada                                

[SrDurden]

                                Entendido el concepto de macro  :ojo:

Pero tengo una duda:

(GetAsyncKeyState(n) & 0x8000)

Que hace exactamente esto? Que devuelve GetAsyncKey? y pq el AND con el 0x8000? No entiendo tampoco el significado de 0x8000 (y similares). Son direcciones de memoria, no? pero en que formato?

Para que el AND? 0x8000 es una máscara?

Y otra pregunta, sobre las funciones inline.. En el Genesis hablan de ellas como funciones a las que no se les pasa parámetros, es decir, que accede a ellas directamente.. Pero como? Se asume que están pasadas por referencia?
Tb he leído que el concepto de una función inline es parecido al de una función Static. Una función en plan Static es una función que solo se carga una vez, por muchos instancias que hagas a una clase, no? Y por tanto debe ser común (o genérica) para que pueda ser utilizada por cualquiera de los objetos de esa clase.
Como relacionar esto con el concepto de Inline? O es otra cosa distinta?

Muchas gracias,

SrDurden 8)                                

[nostromo]

                                SHORT GetAsyncKeyState(int vKey)

Le pasas una tecla virtual (por ejemplo VK_LEFT)
Y te devuelve en el bit más significativo un 1 si la tecla esta pulsada.
El 0x8000 es 8000 en hexadecimal
del numero binario 1000 0000 00000000 00000000 00000000 como puedes ver el bit más significativo, el de la izquierda esta a 1....

El AND como has intuido es para utilizar una mascara(0x8000).... la macro sirve para comprobar si una tecla esta pulsada o no.... devuelve true en caso afirmativo

funciones normales - funciones inline:   (explicación a lo bruto)

Si tenemos la funcion

int lafuncion(int a,int B)
{
  return a + b;
}

// y la llamamos aqui
.........
x = lafuncion(y,z); // Sumamos los numeros
.......

Si coges un compilador y le dices que en vez de codigo objeto te genere un listado en ensamblador te genera algo asi:

lafuncion:
   mov ebp,esp
   mov eax,[ebp+4]
   add eax,[ebp+0]
   ret

............
  push z
  push y
  call  lafuncion    ; sumamos los numeros
  add esp,8  
  mov x,eax
............

Es decir, en una funcion normal,  los parametros los pasa a traves de la pila, apila parametros , hace la llamada , los utiliza , vuelve y desapila....

Si utilizas inline... seguramente con suerte el compilador no pasa los parametros por pila y tampoco realiza la llamada sino que directamente haria la suma tal que asi:

   mov eax,y             ; sumamos los numeros
   add eax,z
   mov x,eax

Con lo que se ahorra toda la llamada y el papeleo de la pila en el mejor de los casos. Ahora bien, siempre que se llame a esta funcion el compilador te metera el codigo de la funcion en el lugar donde la llamas... por lo que si llamas mucho y la funcion ocupa bastante te ocupara mucho el codigo.........

Un saludo
Nostromo                                

[SrDurden]

                                Entendido lo de la función inline, gracias  :ojo:

Una pregunta.. para que el 0x en la dirección?                                

[Mars Attacks]

                                Si no me equivoco, 0x indica al compilador que el número que va a continuación es hexadecimal.                                

[SrDurden]

                                Muchas gracias a todos, por fin lo he entendido todo  :oops:

Saludotes  8)