[argentinator]

Bueno muchachos, voy a tratar de ir comprobando todas estas opciones para Linux, a ver qué conviene más.

Por ahora lo que me preocupa es que los programitas que habrá en el curso son para la línea de comandos de Windows, o sea que carga la ventanita fea de CMD.

Estoy buscando alguna alternativa.

También se puede hacer algún programita con los mínimos requerimientos para generar una ventana básica en Windows, pero quisiera evitar esto en lo posible.

 Pero si es por el color negro, el tamaño de letra, etc., eso se puede cambiar en esa ventana pinchando en la esquina izquierda de arriba (o con le botón derecho del ratón en cualquier parte de la barra de arriba) se abre una lista en la cual una de las opciones es "propiedades", y ahí puedes redimensionarla a gusto, cambiar el color de fondo, el de letra, el tamaño de la fuente...

Es verdad. Nunca me había fijado en esa opción de Propiedades. 

Gracias  , ya hice las modificaciones.
Texto negro sobre fondo blanco y ventana más ancha.

Aún así, sigue siendo molesto el modo de "línea de comandos", ya que me gustaría que aparezca una ventanita de Windows, donde sólo esté la información o interacción con el programa.

Igual no importa, por ahora me conformo con el cambio de configuración del CMD.

[argentinator]

Hummm. Tu consejo no sirve, porque cuando ejecuto el programa compilado en DevC++ se pierde la configuración hecha al CMD en "Propiedades".

 

[argentinator]

Voy a usar la función MessageBox de la biblioteca windows.h.

Es antinatural, pero es una solución simple.

[pierrot]

Hummm. Tu consejo no sirve, porque cuando ejecuto el programa compilado en DevC++ se pierde la configuración hecha al CMD en "Propiedades".

Una posibilidad es llamar al ejecutable desde la consola. No soy muy partidario de ejecutar los programas con el IDE. Además se evita tener que generar pausas innecesariamente con system("pause") o getchar() o cosas por el estilo.

[argentinator]

Fijate que ya incluí una alternativa con MessageBox, que es muy práctica.

A ver cuánto aguantamos con eso.

De paso aproveché para explicar el uso de la compilación condicional en C, aprovechando que tenemos esta disyuntiva de cómo mostrar la salida del "Hola Mundo".

 

[feriva]

Hummm. Tu consejo no sirve, porque cuando ejecuto el programa compilado en DevC++ se pierde la configuración hecha al CMD en "Propiedades".

 

 Pero ¿si lo guardas con el mismo nombre, también? En la consola del XP -que es el que tengo yo en la VirtualBox para que ocupe menos- tiene la opción de guardar los cambios de tal manera que, si se conserva el nombre del archivo, conserva las propiedades de la pantalla; por lo menos ejecutando el programa desde la carpeta, que es como yo lo probé.
 También estuve mirando programas para abrir ejecutables exe, hay uno que abre prácticamente todo tipo de archivo, una especie de llave maestra de abrir programas, que se llama "Open Freely", pero no acabé de instalarlo  porque tardaba y hacía falta no sé cuál programa de Microsoft que no tenía instalado; así que lo dejé de momento.

Sí, si se conserva el nombre de archivo si se ha marcado previamente la casilla "Guardar propiedades para todas las ventanas con el mismo título" antes de "Aceptar" propiedades; aunque lo modifiques y lo recompiles. Ahora bien, cada vez que haces un ejecutable con otro nombre, entonces, sí, hay que configurar, la primera vez al ejecutarlo, las propiedades

Saludos.

[argentinator]

Sí, si se conserva el nombre de archivo si se ha marcado previamente la casilla "Guardar propiedades para todas las ventanas con el mismo título" antes de "Aceptar" propiedades; aunque lo modifiques y lo recompiles. Ahora bien, cada vez que haces un ejecutable con otro nombre, entonces, sí, hay que configurar, la primera vez al ejecutarlo, las propiedades

Saludos.

Sí, esa opción la ví y la usé, pero la idea es que vamos a estar haciendo una multitud de ejecutables distintos, y no que vamos a ejecutar siempre el mismo programa.

Igual no importa, porque gracias a esto me estuve divirtiendo con las directivas del compilador:

http://rinconmatematico.com/foros/index.php?topic=64835.msg260354#msg260354

[feriva]

Igual no importa, porque gracias a esto me estuve divirtiendo con las directivas del compilador:

http://rinconmatematico.com/foros/index.php?topic=64835.msg260354#msg260354

Lo he estado leyendo, ahora voy a probar las cosas...

[feriva]

Una pregunta: por qué defines esto así  #define Creo_que Me_Conformo_con_CMD

 Yo creo entender que la variable es "Creo-que", la cual puede adquirir el valor que tiene "Me_Conformo_con_CMD", por ejemplo, puesto que después se define una variable de comparación (yo  diría que es más de asignación que de comparación) la cual se verificará mediante un condicional if, que es está.

 #define CMD_OK (Creo_que == Me_Conformo_con_CMD)

 Eso me confunde un poco 

[argentinator]

Bueno, el identificador "Creo_que" no es una variable, sino una constante del preprocesador.

El preprocesador y/o el compilador sólo tienen permitido evaluar operaciones o expresiones con constantes directamente especificadas a mano, así: 0, 1, 11.9, "Hello", etc.

Con #define uno puede crear una macro a nivel de preprocesador,
lo cual simplemente permite sustituir una porción de texto por otra.

Cuando declaramos:

#define Creo_que Me_Conformo_con_CMD

lo que estamos haciendo es indicarle al preprocesador que, antes de compilar el programa (y entonces mucho antes de ejecutarlo), reemplace todas las ocurrencias que encuentre de la macro "Creo_que" por la macro "Me_Conformo_con_CMD".

Como "Me_Conformo_con_CMD" también es una macro, este proceso se repetirá reemplazando todas las ocurrencias de "Me_Conformo_con_CMD" con el valor constante que le hemos adjudicado, que en este caso fue simplemente un 0.

Asimismo CMD_OK no es una "variable de comparación", sino una macro, lo cual hace que cada vez que aparezca en el código el identificador CMD_OK será reemplazado automáticamente por la expresión que está a la derecha: (Creo_que == Me_Conformo_con_CMD).

Los identificadores "Creo_que" y "Me_Conformo_con_CMD", tras hacer todos los reemplazos del preprocesador, se terminan reduciendo a constantes.
Nos va a quedar reducido a algo como (0 == 0) o (1 == 0), según lo que hayamos elegido.

En el caso de tener (0 == 0), lo que estamos haciendo es comparar dos constantes.
Esta comparación no la hace en ningún momento nuestro programa ejecutable HolaMundo2bisbis.exe.

El ejecutable no se entera, sino que antes del proceso mismo de compilación la comparación (0 == 0) ya fue realizada, y dio como resultado el valor 1 (VERDADERO, pues 0 es igual a 0).

____________

Lo que estamos haciendo es jugar con las directivas del preprocesador,
para condicionar lo que va a hacer el compilador,
no lo que va a hacer el programa.

En el programa ejecutable no hay ningún IF.

_______________

En cuando a la declaración:

#define CMD_OK (Creo_que == Me_Conformo_con_CMD)

no es una declaración IF.

En realidad el #if se posterga para más adelante.

Ahí lo que hacemos es dejar guardado en una macro el valor de la comparación de las dos constantes.

Así, la macro "CMD_OK" tendrá guardado el valor 1 (VERDADERO) o 0 (FALSO),
y luego la cláusula #if simplemente pregunta por este resultado, que ya ha sido evaluado previamente.

El sentido de usar CMD_OK es sólo una abreviatura, ya que poner en todos los #if la comparación explícitamente "(Creo_que == Me_Conformo_con_CMD)"
sería mucho más engorroso de leer.

Sin embargo, por lo que veo por tus dudas, es menos intuitivo, ya que la comparación no se hace IN SITU, sino antes, y no se ve claramente que estamos interesados en el resultado de dicha comparación.