09 octubre 2013

Compilar C++ en Windows con Visual C++ Express

Visual C++ es parte de la plataforma de desarrollo llamada Visual Studio, de la cual existe una versión llamada Express, que se puede descargar libremente. En este caso, vamos a usar Visual C++ 2010 Express, que no es la última versión, pero requiere menos recursos que la versión 2012 y es más que suficiente para el uso que le puede dar alguien que está empezando a programar (de hecho, también bastaría con Visual C++ 2005 o 2008, pero éstas ya no están disponibles para descargar desde la web "oficial" de Microsoft, aunque sí desde la web para estudiantes de MSDNAA, a la que pueden tener acceso los alumnos de algunos centros educativos).

Desde la propia pantalla de bienvenida tendremos la opción de crear un nuevo proyecto:

vscpp2010_01.png

El tipo de proyecto adecuado para un principiante sería una "Aplicación de consola Win32":

vscpp2010_03.png

Comenzará un asistente, que en este caso se limitará a confirmar si lo que queremos es una aplicación de consola:

vscpp2010_06.png

Y aparecerá un esqueleto de programa, que nos muestra la apariencia que debe tener. Habrá detalles desconcertantes, como que no existe "main" sino "_tmain", y que aparecerá un primer "include" al comienzo del fuente. Deberemos respetar esa estructura, o nuestro programa no compilará correctamente:

vscpp2010_07.png

El cuerpo de nuestro programa irá dentro de "_tmain", y nuestros "includes" deberán seguir al que se nos proporciona:

vscpp2010_09.png

En general, no será necesario compilar antes de ejecutar, porque el entorno se dará cuenta de que hemos modificado el fuente: Si hacemos clic en el botón de "Ejecutar"

vscpp2010_10.png

Se nos preguntaría entonces si queremos generar el ejecutable

vscpp2010_11.png

Pero, al igual que si usamos CodeLite (y la mayoría de entornos integrados para Windows), la ventana de ejecución se abre y se cierra tan rápido que no da tiempo a ver el resultado, así que podemos forzar una pausa añadiendo "cin.ignore()" justo antes de "return":

vscpp2010_12.png

Y así sí podremos comprobar si nuestro fuente ha funcionado correctamente:

vscpp2010_13.png

08 octubre 2013

Compilar C++ en Windows usando CodeLite

Hay varios entornos gratuitos que nos permiten programar en C y C++ bajo Windows de una manera razonablemente sencilla. El más extendido es Dev-C++, pero es antiguo y puede no soportar características recientes del lenguaje. El mismo problema ocurrirá con las versiones más extendidas de CodeBlocks. Por eso vamos a ver una alternativa más reciente y que se actualiza con frecuencia: CodeLite.
CodeLite es un entorno que está disponible para Windows, Linux y Mac. Se basa en el propio GCC (y G++) que se usa para compilar en Linux, al que añade un editor que hace más amigable su uso. Veremos cómo descargarlo y usarlo en Windows. No incluiré las instrucciones para Mac, porque no uso Mac, ni tampoco para Linux, porque Geany es más que suficiente para crear y probar fuentes básicos en ese sistema.

El primer paso será descargar el entorno desde su página oficial (codelite.org). En el momento de escribir este texto, la última versión es la 5.2.

codelite52_instal_01.png

Se nos propondrá donar alguna cantidad, pero no es necesario (en la parte inferior aparece un "No, thanks):

codelite52_instal_02.png

Aparecen varias categorías de descargas, según el sistema operativo. El primer bloque es el de Windows, que descarará tanto el entorno de edición como el compilador.

codelite52_instal_03.png

Se nos llevará a la página de descargas, en Sourceforge, y en un instante debería estar listo para instalar.

codelite52_instal_04.png

La instalación será poco más que pulsar "Siguiente" varias veces, aceptando las opciones que se nos proponen o cambiando las que nos apetezca (por ejemplo, si no queremos que se instale en el disco C sino en alguna otra unidad de disco). Al cabo de un instante, aparecerá el icono en nuestro escritorio.

codelite52_instal_06.png

Y al hacer doble clic veremos la pantalla principal del editor:

codelite52_uso_01.png

Para comenzar, deberemos crear un nuevo proyecto. Lo podemos hacer desde la propia pantalla de bienvenida, un poco más abajo

codelite52_uso_02.png

En el menú "Workspace" tendremos también la opción "New Project", que es equivalente:

codelite52_uso_02b.png

Se nos mostrarán los diversos tipos de proyectos que podemos crear

codelite52_uso_03.png

Y entre ellos, en el bloque "Console" (consola), escogeremos "Simple executable (g++)", para crear ejecutables sencillos de consola en C++ (usando el compilador "g++"):

codelite52_uso_04.png

Sólo faltará indicar el nombre de nuestro proyecto y la carpeta en la que queremos guardarlo:

codelite52_uso_05.png

Se creará el esqueleto del proyecto, pero es posible que aun así, la pantalla de nuestro editor parezca vacía:

codelite52_uso_06.png

Si es el caso, deberíamos desplegar el panel izquierdo ("Workspace") hasta ver nuestro programa principal ("main.cpp").

codelite52_uso_07.png

Al hacer doble clic sobre él, su contenido se mostrará en la ventana de edición:

codelite52_uso_08.png

Ese contenido corresponde a un programa en C. Si queremos trabajar en C++, deberemos cambiarlo por nuestro propio esqueleto:

codelite52_uso_09.png

Para compilar el proyecto y ver si tiene errores, entraremos al menú "Build" y escogeremos la opción "Build project":

codelite52_uso_10.png

O usaremos el botón correspondiente de la barra de herramientas:

codelite52_uso_11.png

Y en el panel inferior se nos mostrará la lista de errores, si es que hay alguno:

codelite52_uso_12.png

Si todo ha ido bien, podemos lanzar la ejecución:

codelite52_uso_13.png

Y quizá se nos recuerde que debemos compilar antes de ejecutar (habría sido fácil para los desarrolladores del editor saber que acabamos de compilar y no hacernos esa pregunta, pero es un detalle incómodo e innecesario que tiene la versión 5.2 de CodeLite y que quizá se mejore en alguna versión posterior):

codelite52_uso_14.png

El problema es que la ventana de ejecución se abrirá y se cerrará tan rápido que no dará tiempo a ver si lo que nuestro programa muestra en pantalla es lo correcto o no. Se puede "solucionar" (de forma poco elegante) añadiendo "cin.ignore()" al final de nuestro programa, justo antes de "return":

codelite52_uso_16.png

Y esta vez ya sí podremos comprobar si nuestro programa ha funcionado correctamente:

codelite52_uso_17.png

07 octubre 2013

Compilar C++ en Linux con Geany

A raíz de la "Introducción a C++" que voy creando a ratos sueltos, he preparado unas instrucciones básicas sobre cómo compilar en C++ usando varios entornos gratuitos: Geany, CodeLite y Visual C++ Express.

Lo dejo aquí en tres entregas, por si a alguien le resulta útil...

Compilar fuentes sencillos en C++ usando Linux
El primer paso es encontrar un editor con el que puedas teclear tus programas. En el menú, dentro del apartado "Accesorios", es fácil que tengas un editor de textos, como GEdit:
cppLinux01.png
Aparecerá la pantalla del editor, todavía vacía:
cppLinux02.png
Podemos empezar a teclear nuestro programa. La sintaxis no se verá en colores todavía.
cppLinux03.png
En el momento en que guardemos los cambios, es fácil que el editor empiece a destacar la sintaxis en colores:
cppLinux04.png
Para compilar el programa y crear un ejecutable, podemos abrir un "Terminal", al que también deberíamos poder acceder desde el menú:
cppLinux05.png
La orden que usaremos para compilar es "g++". Deberemos indicar el nombre de nuestro fuente. Si queremos indicar un nombre para el ejecutable, deberemos usar la opción "-o"; si no es así, el ejecutable se llamaría "a.out".
cppLinux06.png
Si no recibimos ningún mensaje de error como respuesta, podremos lanzar el ejecutable, indicando su nombre precedido por "./":
cppLinux07.png
Geany es un editor más adecuado para programadores, que permitirá compilar nuestro programa y ejecutarlo desde el propio editor. Una vez lo hayas instalado mediante el gestor de software de tu sistema, debería aparecer en un menú llamado "Desarrollo" o "Programación":
cppLinux08.png
Al igual que ocurría con GEdit, veremos la pantalla de edición vacía cuando entremos:
cppLinux09.png
Y podremos comenzar a teclear nuestro fuente, que no se verá en colores todavía
cppLinux10.png
Pero en cuanto lo guardemos con un nombre terminado en ".cpp", la sintaxis quedará realzada con colores:
cppLinux11.png
Tenemos un botón que nos permite "compilar" nuestro fuente:
cppLinux12.png
Y en la parte inferior de la ventana de Geany se nos mostrarán los errores o el resultado correcto de la compilación
cppLinux13.png
Aun asi, este paso comprueba errores pero todavía no crea un ejecutable. Para obtenerlo, deberemos usar la opción de "construir:"
cppLinux14.png
Y nuevamente se nos mostrarán los errores o se nos avisará de que todo ha sido correcto:
cppLinux15.png
Si no había problemas, podremos ejecutar nuestro programa, para ver su resultado:
cppLinux16.png
Y dicho resultado se nos mostrará en una ventana nueva, y se pausará hasta que pulsemos Intro:
cppLinux17.png

29 agosto 2013

Funciones en PseInt

PseInt es quizá el intérprete de pseudocódigo en español más extendido. Desde hace pocos meses, permite definir funciones. Aquí tienes unas nociones básicas sobre cómo hacerlo...

En muchos casos, nos encontraremos con tareas que tenemos que repetir varias veces en distintos puntos de nuestro programa. Si tecleamos varias veces el mismo fragmento de programa no sólo tardaremos más en escribir: además el programa final resultará menos legible, será más también será más fácil que cometamos algún error alguna de las veces que volvemos a teclear el fragmento repetitivo, o que decidamos hacer una modificación y olvidemos hacerla en alguno de los fragmentos. Por eso, conviene evitar que nuestro programa contenga código repetitivo. Una de las formas de evitarlo es usar "subrutinas", una posibilidad que permite casi cualquier lenguaje de programación, y que en ocasiones recibe el nombre de "procedimientos" o de "funciones" (a veces, con algún matiz que hace que esas palabras no sean realmente sinónimos).

PseInt permite definir "subrutinas" (o "funciones") dentro del pseudocódigo, desde la versión del 10 de octubre de 2012. En su caso, se llaman "subprocesos". Veamos un ejemplo de su uso:

Vamos a empezar por crear un subproceso (o "subrutina", o "procedimiento") que escriba 20 guiones, que podríamos utilizar para subrayar textos. Un programa completo que escribiera tres textos y los subrayara podría ser:

Proceso SubProcesos01
    Escribir " Primer ejemplo"
    Para x <- 1 Hasta 20 Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""
 
    Escribir " Segundo ejemplo"
    Para x <- 1 Hasta 20 Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""
 
    Escribir " Tercer ejemplo"
    Para x <- 1 Hasta 20 Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""
FinProceso
 

Muy repetitivo. Sería un poco más elegante si lo reescribimos así:

Proceso SubProcesos02
    Escribir " Primer ejemplo"
    Subrayar
 
    Escribir " Segundo ejemplo"
    Subrayar
 
    Escribir " Tercer ejemplo"
    Subrayar
FinProceso
 
Subproceso Subrayar
    Para x <- 1 Hasta 20 Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""    
FinSubproceso
 

Mucho más legible. Pero todavía no está tan bien como debería: siempre estamos escribiendo 20 guiones, aunque el texto sea más largo o más corto. En la mayoría de lenguajes de programación se puede indicar detalles adicionales ("parámetros") para que se puedan utilizar desde dentro de esa subrutina. Por ejemplo, en nuestro caso podríamos indicarle qué texto queremos escribir y qué longitud queremos que tenga la secuencia de guiones:

Proceso SubProcesos03
    EscribirSubrayado(" Primer ejemplo", 16)
    EscribirSubrayado(" Segundo ejemplo", 17)
    EscribirSubrayado(" Tercer ejemplo", 16)
FinProceso
 
Subproceso EscribirSubrayado(texto, cantidad)
    Escribir texto
    Para x <- 1 Hasta cantidad Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""    
FinSubproceso
 

Aunque todavía es un poco redundante: en general, querremos escribir tantos guiones como letras tenga el texto, así que no será necesario indicar ese dato. Desde octubre de 2012, PseInt incluye ciertas funciones predefinidas para manejo de cadenas de texto; una de ellas es "Longitud", que nos indica la cantidad de letras que tiene un texto, de modo que nuestro programa se podría simplificar así:

Proceso SubProcesos04
    EscribirSubrayado("Primer ejemplo")
    EscribirSubrayado("Segundo ejemplo")
    EscribirSubrayado("Tercer ejemplo")
FinProceso
 
Subproceso EscribirSubrayado(texto)
    Escribir texto
    Para x <- 1 Hasta Longitud(texto) Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""    
FinSubproceso
 


También podemos crear funciones que realicen ciertas operaciones aritméticas y devuelvan un resultado, como las funciones matemáticas que vimos en el tema 10. Se puede hacer con la misma palabra "subproceso" que hemos empleado hasta ahora, pero muchos lenguajes de programación distinguen entre un "procedimiento" o "subrutina", cuando se da una serie de pasos pero no se devuelve ningún valor, y una "función", cuando sí se devuelve un resultado, así que usaremos esta última nomenclatura. Se parece mucho a lo que hemos hecho hasta ahora, con la diferencia de que escogeremos un nombre para la variable que guardará el resultado, así:

Funcion resultado <- Maximo( n1, n2)
    Si n1 > n2  Entonces
        resultado <- n1
    Sino
        resultado <- n2
    FinSi
FinFuncion
 
Proceso Funciones01
    Escribir "El máximo de 5 y 12 es:"
    Escribir Maximo(5,12);
    Escribir "El máximo de 25 y 12 es:"
    Escribir Maximo(25,12);
Finproceso
 

Este programa crea una función que calcula cuál es el mayor de los dos números que se le indican como parámetro, y la usa dos veces, para mostrar el máximo de dos valores prefijados.

No sólo pdemos devolver valores numéricos; también podemos devolver cadenas (como las funciones que vimos en el apartado 13) o "valores de verdad" (verdadero, falso). Por ejemplo, podemos crear una función que diga si un número es primo o no (lo vamos a hacer de la forma más simple pero también de la menos eficiente: aplicar la definición, probando a dividir entre todos los números que hay entre 1 y n; si hemos encontrado dos divisores -o menos, para el número uno-, entonces el número es primo):

SubProceso resultado <- Primo ( num )
    cantidadDivisores <- 0
    Para cont <- 1 Hasta num Hacer
        Si num % cont = 0 Entonces
            cantidadDivisores <- cantidadDivisores + 1
        FinSi
    Fin Para
    Si cantidadDivisores <= 2 Entonces
        resultado <- verdadero
    Sino
        resultado <- falso
    Fin Si
Fin SubProceso
 
Proceso PrimosDel1Al30
    Para n <- 1 hasta 30
        si Primo(n) Entonces
            Imprimir n
        FinSi
    FinPara
FinProceso
 
 

Si quieres más detalles sobre el pseudocódigo o sobre PseInt, aqui los tienes.

15 julio 2013

Google Code se queda sin descargas

Google Code era una alternativa sencilla y cómoda a otros sitios web de alojamiento de proyectos de código abierto, como Sourceforge o GitHub. Era fácil llevar el control de versiones con SVN (Subversion), Git o Mercurial, se podía crear un Wiki en el que incluir la documentación del proyecto y se podían dejar descargas de versiones listas para usar.

Pero ya no todo es así. Desde final de mayo, los nuevos proyectos ya no incluyen la pestaña de Descargas (downloads), ni los proyectos anteriores que todavía no tenían descargas. Y los proyectos que ya contenían descargas pronto dejarán de permitir descargas nuevas (el 15 de enero de 2014).

La excusa es el mal uso que algunos hacían. Sugieren a los usuarios utilizar Google Drive, pero el manejo va a ser mucho menos transparente (hay que recurrir a un servicio externo, crear enlaces públicos e incluirlos en la documentación del proyecto) y mucho menos versátil (no existe la posibilidad de poner etiquetas, por ejemplo). ¿Y si entre todos tus proyectos, sumados a tus documentos personales, necesitas más de 15 Gb? Pues te sugieren que pagues por tener más espacio en Google Drive. Muy triste.

Se queda cojo algo que para mí era una magnífica herramienta para usar en clase con mis alumnos. Tras el cierre de Reader, este es un nuevo error de Google, que cada vez mira más la forma de sacar dinero de sus productos y descuida más la poca parte de servicios "aparentemente desinteresados" que todavía prestaba al usuario.

Más detalles en

http://google-opensource.blogspot.se/2013/05/a-change-to-google-code-download-service.html

y en

https://code.google.com/p/support/wiki/DownloadsFAQ

07 julio 2013

Python básico para programadores

Unas nociones básicas de Python, para gente que ya ha programado en algún otro lenguaje...

Entrada/salida básica

La orden para escribir es "print". En Python 3 necesita paréntesis (es una función), pero no los necesita en versiones anteriores.
Podemos pedir datos al usuario mediante consola con "input". Si los datos son numéricos, podemos usar "int(input())" para convertirlos.
Las líneas no necesitan punto y coma: cada orden termina al final de la línea correspondiente.
No es necesario declarar "variables": se inicializan automáticamente la primera vez que se usan, y el tipo de datos se deduce automáticamente a partir de su declaración:

print ("Dime un numero")
primerNumero = int( input() )
print ("Dime otro numero")
segundoNumero = int( input() )
print ("Su suma es ")
print (primerNumero + segundoNumero)
 

Condiciones

Existe una orden "if" para comprobar condiciones. La condición que se verifica no necesita estar indicada entre paréntesis, al contrario que en los lenguajes que derivan de C (como C, C++, C#, Java, PHP y algún otro).
La línea del "if" debe terminar con un símbolo de "dos puntos", y todo el bloque de órdenes que se va a ejecutar en caso de que se cumpla la condición, estará tabulado algo más a la derecha (típicamente 4 espacios; el mínimo es dos... o un carácter de tabulación).
Para indicar qué hacer si no se cumple la condición, tenemos una cláusula "else" opcional, que también debe ir seguida por un símbolo de "dos puntos":

num1 = int(input( "Dime un numero " ))
num2 = int(input( "Dime otro numero " ))
if num1 > num2:
    print( "El primero es mayor" )
else:
    print ("El segundo es mayor" )
 

Condiciones múltiples

No existe "switch" o "case", pero se pueden enlazar varios "if" sin necesidad de tabular cada vez más a la derecha, si se emplea "elif" (abreviatura de "else if"):

nota = int(input("Introduzca la nota "))
if nota == 10:
    print ("Sobresaliente alto")
elif nota == 9:
    print ("Sobresaliente bajo")
elif nota == 8:
(...)
 

Repeticiones

Podemos repetir bloques de órden con "while", que tiene una sintaxis muy similar a "if". No existe un repeat-until, ni un do-while, que se pueden conseguir modificando ligeramente la estructura del "while" para garantizar que siempre se dé un primer paso:

print ("Dime un numero")
x = int( input ( ) )
suma = 0
while x != 0:
  suma = suma + x
  print ("La suma es {}".format(suma) )
  print ("Dime otro numero")
  x = int( input ( ) )
print ("Terminado")
 

Contadores

Si queremos contar del uno al 10, lo podemos hacer con un "while", pero también existe una orden "for", que recorre los valores de un conjunto; si se trata de un contador, lo habitual es crear un "rango de valores" usando "range", al que se le indica el valor inicial (incluido) y el valor final (no incluido):

for x in range(1,11):
  print (x) 
 

Y si queremos que no vaya de uno en uno, podemos añadir un tercer parámetro, el incremento:

for x in range(10,21,2):
  print (x)
 

Funciones

Las funciones se definen con la palabra "def". A continuación, se indica el nombre de la función, los parámetros y el símbolo de dos puntos. El contenido de la función deberá estar tabulado más a la derecha, como siempre:

def saludar(nombre):
    print ("hola")
    print (nombre)
 

Si la función devuelve valores, el único cambio será incluir la correspondiente sentencia "return":

def sumar(x,y):
    return x+y

26 mayo 2013

Android Studio no arranca en Windows

Ya iba siendo hora de probar el recién lanzado Android Studio ("early access preview"), de Google, que se puede descargar desde:

http://developer.android.com/sdk/installing/studio.html

Lo hice hace cerca de una semana, se instaló sin problemas pero no arrancó. Hoy me he tomado el tiempo de reinstalar y mirar con más detenimiento... y sí, estaba correctamente instalado, y no funcionaba por un problema de configuración que el instalador (para Windows) no soluciona:

Es necesario añadir una variable llamada JDK_HOME al PATH de nuestro sistema.

Hay quien habla de que también sirve si se llama "ANDROID_STUDIO_JDK" o "JAVA_HOME", pero yo voy a incluir los pasos que me han servido a mí, bajo Windows 8.

Para cambiar esa variable tenemos que llegar hasta el apartado "Sistema" de nuestro Panel de Control. Se puede conseguir entrando al Panel de Control, luego al apartado "Sistema y Seguridad" y luego a "Sistema". En la columna del lado izquierdo debería aparecer la opción "Configuración avanzada del sistema", que despliega una nueva ventana, en cuya parte inferior hay un botón "Variables de entorno...".



La parte superior mostrará la leyenda "Variables de usuario para XXX" (donde XXX será nuestro nombre de usuario). Si pulsamos el botón "Nueva...", aparecerán dos casillas, en las que podremos añadir la variable de entorno y su valor.

En este caso, escribiríamos JDK_HOME en la casilla superior, y en la inferior pondríamos la carpeta en la que se encuentra nuestro JDK de Java, que puede ser algo como

C:\Program Files (x86)\Java\jdk1.6.0_39

o como

C:\Program Files\Java\jdk1.7.0_21

Entonces, ya podremos entrar a Android Studio, pero puede que al elegir "New Project" nos avise de que sea necesario actualizar nuestro Android SDK, si tenemos una versión inferior a la 22 (en mi caso, tenía la 21).



Basta abrir el "SDK Manager" para que detecte las actualizaciones y nos ofrezca instalarlas. Si el mensaje persiste, hay que hacer caso a la segunda mitad de lo que nos avisa: quizá nos falten plantillas ("is missing templates"). El problema también puede deberse, como en mi caso, a que no haya detectado correctamente la carpeta en la que está el SDK. Se lo podemos indicar a Android Studio si entramos a:

Configure, Project Defaults, Project Structure, Project


En mi equipo, el SDK no estaba en la carpeta en la que el instalador esperaba, porque no lo instalé para todos los usuarios. En cuanto le indiqué la ruta correcta (pulsando el botón "..." que hay tras "Android SDK home path"), las cosas empezaron a funcionar: