¿Es correcto esto?

[Mcur]

Sin duda la declaración-definición de las variables en el contexto es la idea más interesante por lo menos para mí (Cada uno al fin y al cabo programa como le da la gana)

Si todas las variables las declaramos antes del main() todas serian globales, creo que limitar en programación es conveniente. La encapsulación en C++ me parece fascinante, tu propio diseño te prohíbe cagarla, creo que contextualizar las variables es también un acierto.

[Fran]

Creo (me suena haberlo leido) q la gran diferencia entre una y otra cosa (aunque a día de hoy creo q eso importará poco) viene de cuando el como se implementaban las cosas en ASM eran importantes. En ASM si no recuerdo mal habia un tipo de registro que era para contadores. Si directamente le dices q esa variable es un contador , optimiza mucho mas

[Güarmigue]

Eso del contexto de las variables está muy bien si tienes un contexto, pero si simplemente quieres un contador puedes llamarlo 'c' y usarlo en distintos bucles sin problemas.

Aunque haya muchas lineas de código de por medio y tengamos muchas variables con su nombre adecuado para el contexto donde van a ser usadas, yo prefiero tenerlas todas arriba con un pequeño comentario de para que sirven. Como dice Vicente es cuestión de gustos, siempre lo he hecho así y estoy acostumbrado. Si quiero saber que variables tengo en un momento dado, me voy a la parte superior del código. Además, el ver declaraciones repartidas por todas partes simplemente no me gusta, me da sensación de desorden.

Como diría el piedraita: ahhh, en mi casa programamos así  8)

En cuando a ensamblador... en lugar de indicar int o char indicas bytes y asignas una etiqueta. No es lo mismo, pero es realmente parecido. Solo que en este caso si que hay que declarar cada cosa en su lugar (segmento de datos, de código, de pila...)

[RobiHm]

creo que ya lo han comentado pero me hace ilu participar xD

yo lo se por java
al declararla en el bucle esa variable solo es local a ese bucle
al declararla fuera del bucle es local a todo el proceso en el que se encuentre

¿cómo habría que declararla?

si es un for, se debería declarar en el bucle, puesto que en los fors no se debe utilizar el contador fuera del bucle

si es un while, no queda otra que declarala fuera ya que los contadores de bucles while de programación estructurada las utilizan fuera...

realmente nose xk se hace asi xD
yo lo atribuyo al tikismitismo del orden

[ethernet]

yo lo se por java

Yo no tomaría a java como ejemplo de nada...

[Zaelsius]

Lo mejor es declarar las variables cuando vayas a usarlas, tal y como ya han dicho. El código resultante suele ser más legible para terceras personas y se evitan errores derivados de reutilizar variables.

Además, la limitación de declarar las variables al comienzo viene de los antiguos compiladores(años 70-80).. no por otra cosa, ya que era mucho más fácil programar un compilador para un lenguaje que tuviese este tipo de limitaciones.

Hoy en día la historia ha cambiado y afortunadamente tenemos compiladores bastante más inteligentes. Así que no sigais programando como en los 80 ;)

[[Vil]]

Yo uso las variables conforme las necesito, y nada de declarar a principios de función... la cosa es que más de uno me ha criticado eso mil veces. Aprendí directamente haciéndolo así y ahora me parece un graaan coñazo tener que hacerlo de la otra forma, por mucho que me digán que es mejor declarar todo al principio.

[TheAzazel]

Lo que dan de si dos lineas iguales en C/C++!!! jjajajajaajja

que si optimiza mas que si menos, que si mas memoria que si menos, que si mas legible que si menos....

no se, pero para mi todo esto entra dentro del gusto de cada uno y el rendimiento y memoria debe ser tan insignificante que es completamente despreciable...ahora sola falta alguno que le pase a ese codigo el Vtune y nos de los ciclos que consume uno u otro :P

[Mars Attacks]

Eres duro, ethernet =**************** me pones más que el yeins bon ése saliendo en gallumbos de la playa.

XD

[ethernet]

Eres duro, ethernet =**************** me pones más que el yeins bon ése saliendo en gallumbos de la playa.

XD

:***

[blau]

El tema de usar una misma variable de contador para distintos bucles, lo unico que va a provocar es algun fallo de programacion si anidas bucles, y si lo declaras todo global no te digo nada.



Lo interesante de la variable dentro de la declaracion del bucle es que el compilador va a tratar por todos los medios de usar un registro del procesador para lamacenarla, de forma que no accederia a memoria siquiera.

[sés]

Yo voto sin duda alguna por:

Código [Seleccionar] Expand

for( int i=0; i<N; i++ ) {... }

Incluso cuando necesito un miniproceso que no voy a convertir en función:

Código [Seleccionar] Expand

if( true ) {
 float scaleX = screenWidth / 640;
 float scaleY = screenHeight / 480;
 for( int i=0; i<N; i++ ) {
   sprite[i].scale( scaleX, scaleY );
 }
}

Realmente el if( true ) no es "necesario" y serviría con poner las llaves, pero te permite ponerlo a false en un momento dado y eliminar esa parte de código.

Y viene muy bien para pruebas temporales, ya que cualquier compilador eliminará el código dentro de un if( false ) ;)

[Buffon]

Hombre supongo que eso ya dependerá de gustos, pero a mi me enseñaron todo eso de la programación estructurada, separar el código de la declaración de variables... y me he eacostumbrado y me gusta así.

void hacerAlgo()
{
  int var1;
  int var2;
  int var3;

   cosas con var1;
//100 lineas después
  cosas con var2;
//100 lineas despues
  cosas con var3;

}

qué prefieres, declararlas donde toca o al comienzo? Ahora los editores dan mucha ayuda y no importa tanto, pero lo mejor (para mi) es declarar la variable en el contexto, por ejemplo:

for(int nSprites = 0; nSprites < maxSprites; nSprites++)
{
  renderSprite(nSprite);
}

si declaro la variable en el bucle es mucho más lógico que hacerlo al comienzo.

Crear variables en todas partes hace que sea más dificil calcular la memoria estática que utilizas en caso de que te haga falta (por ejemplo en ensamblador, ¿móviles?)  

Con ensamblador no hay variables (tal cual hablamos ahora) y en los móviles con la puta mierda de VM que hay sería imposible saber la memoria que usas.

y además puede llevar a declarar variables de distintos tipos de datos con el mismo nombre en distintas zonas de código, con lo que al final no sabes si 'c' es un int, un char o cualquier otra cosa.

Las variables pierden su validez cuando no están en su contexto (otro punto más para tener variables por bloques) y el nombre c de una variable no es precisamente adecuado.

en un principio que una misma función tenga más de 30 lineas es una guarrada, por muchos motivos y entre uno de ellos es el de debugar.

La única diferencia de declarar la variable al principio o en el momento, es que en un caso estás usando siempre 4 bytes de memoria ocupada en la pila del proceso, en el otro caso sólo cuando entras en el bucle, al salir del bucle se hacen los pops necesarios y esa variable ya no existe.

Cierto es que para programar en un dispositivo móvil, si que importa como está la pila en cada momento y no es lo mismo tener 20 elementos declarados al principio, 20*4 = 100 bytes, que hacerlo en el momento de entrar en el bucle que tendrás sólo 4 bytes extras.

Si a estas pijadas le sumamos muchas otras, acabas de tener una aplicación eficiente en un sentido u otro, pero nunca lloverá a gusto de todos.

en este caso hablamos de ANSI C, con lo cuál debe declararse al principio.

[ethernet]

Si la definición de la eficiencia de una aplicación son los bytes que usas de stack mal vamos. Sinceramente es algo de lo que nunca me había preocupado y de lo que creo que se puede sacar poquísimo jugo. Por esa misma razón es preferible darle ventaja a la mantenibilidad que a la eficiencia.

[AK47]

Yo creo que la mantenibilidad es el concepto clave, el juez que separa al buen programador del resto: puede que tu programa vaya más o menos rápido, pero siempre puedes meterle mano. Sino, tu código está muerto y su evolución es imposible o terriblemente costoso.