¿Qué es lo correcto y por qué? porque parece que no influye para nada.
//METODO 1
for(int x = 0; x<10; x++)
//METODO 2
int x;
for(x = 0; x<10; x++)
S2.
Si no me equivoco, en C++ puedes declarar en el interior de un bycle for, mientras que en C debes declarar antes de definir dentro del propio for.
La primera opción seria para C++ y la segunda para C y C++.
Pero bueno, soy novato novato, llevo solo unos meses estudiando C++ y prefiero que te lo confirme uno de los maquinas que hay por aquí.
Un saludo.
Cita de: "currilingo"Si no me equivoco, en C++ puedes declarar en el interior de un bycle for, mientras que en C debes declarar antes de definir dentro del propio for.
La primera opción seria para C++ y la segunda para C y C++.
Pero bueno, soy novato novato, llevo solo unos meses estudiando C++ y prefiero que te lo confirme uno de los maquinas que hay por aquí.
Un saludo.
Los novatos suelen ser los que más saben de esas cosas tan particulares que te deben comentar cuando estás aprendiendo ;)
Sí que estás en lo cierto en tu afirmación, desconozco si influiría en alguna cosa más.
A nivel de compilador supongo que sera en que la variable solo existe y tiene su ciclo de vida dentro del bucle for. Esto es, se crea e inicializa en la declaracion del for y se extinge al finalizar el bucle. De la otra forma la variable se crea en su declaracion y se extinguira al finalizar la funcion.
Esto al menos se que en C# es asi. No se si cambiara en C++.
Salu2...
Da lo mismo que lo mismo da... :P
No hay forma mas bonita de comprobarlo que probarlo :D
[EX3] y currilingo, teneis los dos razón. Por lo tanto para ahorrar memoria, declararias la variable dentro del bucle solo en el caso de que no te sirva para nada más esa variable. Pero para el caso de que estes usando lenguaje C deberia de hacerlo con el segundo metodo.
Cita de: "yEnS"Cita de: "currilingo"Si no me equivoco, en C++ puedes declarar en el interior de un bycle for, mientras que en C debes declarar antes de definir dentro del propio for.
La primera opción seria para C++ y la segunda para C y C++.
Pero bueno, soy novato novato, llevo solo unos meses estudiando C++ y prefiero que te lo confirme uno de los maquinas que hay por aquí.
Un saludo.
Los novatos suelen ser los que más saben de esas cosas tan particulares que te deben comentar cuando estás aprendiendo ;)
Sí que estás en lo cierto en tu afirmación, desconozco si influiría en alguna cosa más.
Pues los novatos mejor que nadie deberían saber que en C las variables se declaran al principio de la función y no después :) (aunque se hagan antes de un bucle for)
Ahí está, lo suyo es declarar al principio de la función, además, así, si tienes que usar de nuevo un contador para otro bucle o lo que sea no tendrás que volver a declarar... con el consiguiente ahorro de memoria :)
Parece una tontería, pero si quieres hacer las cosas bien o optimizar por algún motivo, es mejor el segundo método. Además el código siempre es mas limpio y legible cuando está ordenado.
No hay forma mas bonita de comprobarlo que probarlo :D
Cita de: "Güarmigue"Ahí está, lo suyo es declarar al principio de la función, además, así, si tienes que usar de nuevo un contador para otro bucle o lo que sea no tendrás que volver a declarar... con el consiguiente ahorro de memoria :)
depende de como funcione el compilador. Aparte, un ahorro de 4 bytes no es que vaya a llevar a ninguna parte. De todas formas si creas y destruyes la variable finalmente usarás la misma memoria, tal vez ahorras ciclos en sumas y restas de puntero de pila.
Cita de: "Güarmigue"
Parece una tontería, pero si quieres hacer las cosas bien o optimizar por algún motivo, es mejor el segundo método. Además el código siempre es mas limpio y legible cuando está ordenado.
A mi me parece más limpio usar variables para una cosa en vez de usar varias veces la misma variable en la misma función para distintas cosas.
CitarA mi me parece más limpio usar variables para una cosa en vez de usar varias veces la misma variable en la misma función para distintas cosas.
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í. 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?) 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.
La programación estructurada y eso de declarar las variables primero y luego ya el código en sí viene de la época en que los compiladores pedían eso como requisito para compilar. A mucha gente le gusta no declarar las variables excepto cuando se van a necesitar.
Cuestión de gusto. Un saludo!
Vicente
...
Cita de: "Güarmigue"
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.
Cita de: "Güarmigue"
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.
Cita de: "Güarmigue"
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.
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.
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
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...)
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
Cita de: "RobiHm"
yo lo se por java
Yo no tomaría a java como ejemplo de nada...
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 ;)
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.
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
Eres duro, ethernet =**************** me pones más que el yeins bon ése saliendo en gallumbos de la playa.
XD
Cita de: "Mars Attacks"Eres duro, ethernet =**************** me pones más que el yeins bon ése saliendo en gallumbos de la playa.
XD
:***
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.
Yo voto sin duda alguna por:
for( int i=0; i<N; i++ ) {... }
Incluso cuando necesito un miniproceso que no voy a convertir en función:
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 ) ;)
Cita de: "ethernet"Cita de: "Güarmigue"
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.
Cita de: "Güarmigue"
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.
Cita de: "Güarmigue"
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.
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.
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.