[Tutoriales] C++

1. Introduccion

Voy ha hacer unos tutoriales de C++ para que podais aprender y de paso podais programar un poco.

El c++ es uno de los lenguajes de programación, es muy potente lo que nos permite crear cualquier tipo de programa que nos propongamos. Para que os hagais una idea. Windows y Linux fueron creados en C++... En contra, tiene la fama de ser de los más rígidos. Por ello también es idóneo para empezar, ya que vas cogiendo buenas costumbres.

Aunque puede utilizarse en cualquier plataforma, normalmente está pensada para PC. Y como tal nos centraremos en esa rama.

Por último, indicar que estos tutoriales no te darán los conocimientos necesarios para crear un juego comercial (ni mucho menos en 3D). Tampoco te darná suficientes conocimientos como para hacer un programa estilo Firefox. Para todo eso necesitas mucha experiencia con el lenguaje y muchísimo aprendizaje.

Los tutoriales se centrarán en el lenguaje C++ para que lo comprendas y tengas un manejo bueno con él.

1.1 Breve Descripción del lenguaje

Como lenguaje de programación, básicamente lo que haces es escribirle al ordenador "lo que tiene que hacer". Por ejemplo, que muestre un texto, que mueva la pantalla de tal forma, que guarde tal valor...

Sin embargo. Los ordenadores solo saben leer codigo binario. ¿Cómo puede leer entonces un programa en C++?

El sistema que usa C++ es usa un programa llamado "Compilador". Ese programa tiene como función, transformar y traducir el codigo C++ al codigo binario de forma que el ordenador lo pueda entender.

1.2 Introducción al entorno

Existen muchos compiladores de C++. Nosotros usaremos el DevCPP que además es gratis. Podemos encontrarlo en el siguiente link:
http://www.bloodshed.net/dev/devcpp.html

El primer archivo es el instalador, el segundo es la version portable y el tercero es el codigo fuente... Nos descargamos unas de los dos primeras y lo abrimos:



Haremos una pequeña prueba para ver si funciona correctamente. Clickamos en Archivo -> Nuevo -> Proyecto:





Seleccionamos "Console Application" y el lenguaje C++. Y si queremos le pondremos algun nombre chulo (no vale usar espacios, eñes y tildes). Le damos aceptar y guardamos el proyecto donde queramos. Nos saldrá ahora una hoja con el siguiente codigo:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
system("PAUSE");
return EXIT_SUCCESS;
}

Ese es el codigo básico de cualquier programa en C++. En el siguiente tutorial lo veremos más a fondo, de momento escribiremos la siguiente línea:

cout<<"Hola Mundo! ";

Escribimos esta línea entre la llave { y el "system("PAUSE")":

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
cout<<"Hola Mundo! ";
system("PAUSE");
return EXIT_SUCCESS;
}

Ahora pulsamos Ejecutar -> Compilar y Ejecutar (o bien, pulsamos F9). Nos saldrá nuestro primer programa en pantalla:



Si en el codigo cambiamos el "Hola Mundo" por otra cosa, nos sadrá un texto diferente (importante dejar las comillas).

Y aquí tenemos nuestro primer programa, inútil pero funcional. En los siguientes tutoriales empezaremos a dar nuestros primeros pasos en el lenguaje.

2. Concepto básicos del lenguaje

Empezaremos recordando el código "básico" de cualquier programa C++

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
system("PAUSE");
return EXIT_SUCCESS;
}

Analizemos cada línea por separado:

#include <cstdlib> Esta línea empieza con un #. Lo cual quiere decir que no forma parte del programa, sino que es una anotación para el compilador.

Esta # empieza con un include, lo cual quiere decir que incluya un determinado archivo al programa. De modo que pueda ser usado y leído. Lo que está incluyendo allí es la librería Stidio del compilador. Gracías a esa librería podremos escribir textos, trabajar con archivos externos y alguna que otra cosa más. De momento, basta con que sepais que gracias a ese archivo podreís escribir texto en la pantalla.

#include <iostream> Esta línea es similar a la anterior, solo que se incluye la librería iostream. De momento no vamos a usar esa librería asi que podemos borrar esa línea del programa.

using namespace std; Es un complemento para que podamos usar la función cout que veremos más adelante, de momento lo dejamos así.
int main(int argc, char *argv[])
{ Esto quiere decir el comienzo del código del main, el main es lo primero que se ejecuta al abrir un programa.

A continuación pondríamos el cuerpo del programa, hasta llegar a

system("PAUSE"); El programa se ejecuta en decimas de segundo, si queremos que se espere antes de cerrarlo tenemos que utilizar esta función.

return 0;
} Se cierra una llave para indicar que el main ha terminado, aunque no es imprescindible. Se recomienda que se ponga return 0 también. Que le viene a significar que el programa ha terminado correctamente

Y por ultimo, queda por mencionar el //

Sirve para hacer anotaciones en el programa. No se tiene en cuenta para compilar, solo sirve de guia para ti u o otra persona que vea el codigo. Es de buenos programadores hacer muchas anotaciones al código.

Los codigos que pondré hare anotaciones de este mismo estilo para guiaros.

2.1 Mostrar un texto por pantalla

A continuación os presentaré la siguiente función:

cout<<"Inserta tu texto aquí";

Con esta función podremos escribir un texto por pantalla. Simplemente colocamos lo que queremos escribir entre las comillas. Importante el punto y coma del final, todas las funciones de C++ tienen un punto y coma al final.

Si queremos hacer un salto de línea usaremos la expresión ENDL (sin comillas):

cout<<endl;

Podemos combinar textos y saltos de línea:

cout<<"Primer Texto"<<endl<<"Segundo Texto"<<endl;

2.2 Introducción a las variables

Bien, ahora sabemos como escribir. ¿Pero como leemos datos? Para ello tenemos que guardar los datos en la memoria, y para ello tenemos que usar las variables.

Una variable es un hueco reservado en la memoria con un determinado valor, existen variables de distinto tipo según lo que vayamos a guardar:

char Guarda una letra
int Guarda un número entero
float Guarda un numero con decimales (max 7 decimales)
bool Solo tienes dos valores: Verdadero o Falso (true/false)

Existen variaciones los int, dependiendo del int que uses podrás representar más/menos números y tendrás más/menos consumo de memoria. Por ahora nos conformaremos con los int, pero aquí os dejo la tabla:



¿Cómo usamos una variable? Primero tendremos que declararla para que el compilador sepa que existe, se escribe lo siguiente:

<tipo de variable> <Nombre de variable> = <Valor Inicial>;

Si quisiera crear una variable entera que valiese 5:

int Ejemplo = 5;
// Importante el punto y coma del final

Si quisiera crear una variable decimal que valiese 2,5:

float UnaVariable = 2.5;
// La coma de los decimales se representa con un punto

El nombre de la variable puede ser cualquiera, pero no debe contener ni ñ, ni tildes ni espacios.

Si quisiera crear una variable de letra para que valiese A

char Letrita = 'A';
// La letra en cuestión debe ponerse entre comillas simples

Podemos crear una variable sin darle un valor al principio:

int Numero;

Sin embargo, esa variable podría tener un valor cualquiera (depende de lo que hubiera en la memoria). Por eso es importante darle un valor inicial, aunque sea 0:

int Numero = 0;

2.2.1 Operaciones básicas con Variables

Podemos operar matemáticamente con las variables a nuestro antojo:

Sumas

Numero += 5; // A la variable Numero le sumamos 5
Cosita += 3; // A la variable Cosita le sumamos 3

También podemos sumarle variables:

Numero += Cosita; // A la variable Numero, le sumamos la variable cosita

// Suponiendo que Numero y cosita valgan 5 y 3. El resultado será 8.

Para sumas simples (sumar 1) existe el operador ++:

Numero++; // Le sumamos a la variable Numero 1
Cosita++; // Le sumamos a la variable Cosita 1

Restas

// Tienen un funcionamiento similar a las sumas

Numero -= 5; // A la variable Numero le restamos 5
Cosita -= 3; // A la variable Cosita le restamos 3

Numero -= Cosita; // A la variable Numero le restamos la variable Cosita

Numero--; // Le restamos a la variable Numero 1
Cosita--; // Le restamos a la variable Cosita 1

Multriplicaciones

// Tienen un funcionamiento similar a las sumas

Numero *= 5; // A la variable Numero la multriplicamos por 5
Cosita *= 3; // A la variable Cosita la multriplicamos por 3

Numero *= Cosita; // A la variable Numero le restamos la variable Cosita

// No tiene operaciones para productos simples (multriplicar por 1?)

Divisiones

// Ojo! Se usan de forma similar pero no funcionan igual

Numero /= 5; // A la variable Numero la dividimos entre 5
Cosita /= 3; // A la variable Cosita la dividimos 3

/* El valor del conciente dependerá si la división es entera y la variable también lo es.

Es decir, dividir 3/2 no da 1,5. Sino que da 1 de conciente y 1 de resto, salvo que la variable sea decimal (entonces si saldrá el conciente con decimales

*/

Módulo (o resto)

// Indica el resto de dividir un numero entre otro:

Cosa = 3%2; // Cosa equivale al resto de dividir 3/2, es decir 1.
Numero = 5%2 // Numero equivale al resto de dividir 5/2, es decir 1

Asignación

// Da un valor a una variable

Cosa = 5; // Cosa es igual a 5
Cosa = Numero; // Cosa es igual a la variable Numero

2.2 Lectura de Variables

Una vez que sabemos trabajar con variables, vamos a escribir en ellas.

Para escribir en una variable por teclado, se usa la función cin:

cin>>(Nombre Variable);

Para leer la variable Cosa:

cin>>Cosa;

2.3 Nuestro primer programa (útil)

Vamos ha hacer una especie de calculadora sencillita (por sencillita, significa que solo pueda sumar).

Creamos un proyecto en el DevCpp:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
system("PAUSE");
return EXIT_SUCCESS;
}

Creamos dos variables, una que guarde el número y otro que guarde lo que se le suma. Podemos declarla en cualquier lado, pero es preferible colocarlo dentro del main:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int Numero = 0;
int Sumando = 0;

system("PAUSE");
return EXIT_SUCCESS;
}

Escribimos una introducción al programa:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int Numero = 0;
int Sumando = 0;

cout<<"Bienvenido a la calculadora humana (?) by amchacon"<<endl;
cout<<"Introduce tu primer numero: ";
system("PAUSE");
return EXIT_SUCCESS;
}

Leemos el numero por teclado:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int Numero = 0;
int Sumando = 0;

cout<<"Bienvenido a la calculadora humana (?) by amchacon"<<endl;
cout<<"Introduce tu primer numero: ";
cin>>Numero;
system("PAUSE");
return EXIT_SUCCESS;
}

Repetimos el proceso para el otro:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int Numero = 0;
int Sumando = 0;

cout<<"Bienvenido a la calculadora humana (?) by amchacon"<<endl;
cout<<"Introduce tu primer numero: ";
cin>>Numero;
cout<<"Introduce el valor que le quieres sumar: ";
cin>>Sumando;
system("PAUSE");
return EXIT_SUCCESS;
}

A numero, le sumamos la otra variable:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int Numero = 0;
int Sumando = 0;

cout<<"Bienvenido a la calculadora humana (?) by amchacon"<<endl;
cout<<"Introduce tu primer numero: ";
cin>>Numero;
cout<<"Introduce el valor que le quieres sumar: ";
cin>>Sumando;
Numero += Sumando;
system("PAUSE");
return EXIT_SUCCESS;
}

Mostramos a numero por pantalla:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int Numero = 0;
int Sumando = 0;

cout<<"Bienvenido a la calculadora humana (?) by amchacon"<<endl;
cout<<"Introduce tu primer numero: ";
cin>>Numero;
cout<<"Introduce el valor que le quieres sumar: ";
cin>>Sumando;
Numero += Sumando;

cout<<"El resultado es: ";
cout<<Numero; /* Para mostrar una variable, escribimos el nombre de ella sin comillas */
cout<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}

3. Estructuras Condicionales

Ahora vamos a dar como indicar condiciones y repeticiones en los programas. Algo imprescindible para hacer cualquier programa.

3.1 Condiciones "Sí... Entonces..."

Hablaremos ahora de la estructura if. Sirve para expresar condiciones (si se cumpla tal condicion, que se haga esta cosa, sino que se haga esta otra).

La estructura if es asi:

if (condicion)
{
Suceso que ocurre
}

Esto es muy sencillo, si se cumple la condicion que esta entre parentesis (por ejemplo, que pulses la tecla enter) ocurre un suceso determinado.

Os pongo un ejemplo:

if (1+1 == 2)
{
cout<<"El ordenador sabe sumar";
}

Aqui estamos diciendo que si la suma de 1+1 es igual a 2. Aparecera el texto de ahi.

Supongo que os habreis dado cuenta que he puesto dos veces el igual. Hay que ponerlo dos veces para que compruebe la igualdad. Si no lo hará.

Os pongo otro ejemplo de if por si no os ha quedado del todo claro:

if (Cosita == 5)
{
cout<<"El resultado es 5";
}

Le estamos diciendo que si la variable Cosita es 5. Nos saldra un texto...

Por ultimo queda por decir algunos operadores para el if, por ejemplo para expresar una doble condicion habria que poner:

if ((condicion 1)&& (condicion 2))
{
Suceso...
}

if ((Cosita == 3)&& (Coste == 2))
{
cout<<"Comparados";
cout<<"Alguna cosita mas?"
}

Con esto le estamos diciendo que si se cumplen las dos variables, sucede el codigo entre los corchetes. Podemos encadenar más condiciones usando el mismo método:

if ((condicion 1)&& (condicion 2)&& (Condicion 3)&& (Condicion 4)...)
{
Suceso...
}

Otro operador es el || que seria como decir "o". Para ocurra la accion tiene que cumple una de las dos condiciones. Ejemplo:

if ((Cosa == 2) || (Coste == 3))
{
cout <<"Ha ocurrido algo?";
}

Si cualquier de las condiciones es cierta, aparece el texto de abajo.

Otro operador que vamos a ver es el ! que seria como decir "no". Si la condicion que hemos puesto no se cumple. Comienza la accion. Un ejemplo:

if (Cosa != 5)
{
cout<<"Cosa no es 5";
}

Si cosa no es 5, aparecerá ese texto.

También hay otros operadores para indicar "mayor que", "Menor que":

> (mayor que... )
>= ( mayor o igual )
< ( menor que... )
<= ( menor o igual)

Su uso es idéntico a lo anterior y no creo que haga falta hacer un ejemplo.


3.1.1 La sentencia else

El Else es complementario al if, y sirve para que una accion ocurra si la condicion no es cierta.

if (condicion){

Si la condicion es cierta ocurre esto
}
else{

Si la condicion no es cierta, ocurre esto
}

Podríamos poner otro if, pero sería más lio y es mas eficiente usar esto.

3.1.2 Sentencia Switch

Es una expresion que realiza una determinada accion dependiendo del caso. Por ejemplo, si la variable casa es 1 ocurre tal cosa, si es 2 ocurre otra cosa, si es 3 otra distinta, etc...

Pongamos un ejemplo:

switch(casa)
{
case 1:
cout<<"La variable casa es 1";
break;

case 2: //¿El valor de 'variable' es 2?
cout<<"La variable casa es 2";
break;

case 3: //¿El valor de 'variable' es 3?
cout<<"La variable casa es 3";
break;

default: //Se ejecuta si no es cierta ninguna de las anteriores
cout<<"Ninguna de las anteriores es cierta";
break;
}

Declaramos la variable casa y ponemos el switch. Si la variable casa es 1 mostrara un texto, si es 2 muestra otro texto y si es 3 muestra otro. Si no es ninguna de las anteriores muestra otro texto.

La razon de break que he puesto, es para evitar que el codigo continue. Por tanto debemos poner nuestra accion entre el case y el break;


3.2 Sentencias iterativas "Repitete mientras..."

Como dice el título, sirve para expresar que una sentencia se repita mientras se cumpla la condición:

while (condicion){
//suceso
}

3.2.1 La sentencia do while

Es una variante del while, el codigo de los corchetes se ejecuta con normalidad como si no hubiera nada. Cuando llega al final, comprueba que la condicion y si esta es cierta repite el codigo...

Su estructura es asi:

do
{
Accion
}
while (condicion);

3.2.2 La sentencia for

Otra variante del while pero pensada repeticiones contadas.

Aquí tenemos un ejemplo de sentencia for:

for (int i = 0; i < 20; i++){
cout<<"Spam"<<endl;
}

Analizemos la parte de los parentesis:

(i = 0; i < 20; i++)

Se compone de 3 expresiones:

- La primera es una accion que se ejecutara cuando se ejecute la setencia for... Puede ser cualquier cosa, en esto caso se crea una variable y se le da valor 0...
- La segunda es la condicion, recordamos que esto funciona como un while. Asi que mientras que la condicion sea cierta, el codigo entre los corchetes se ejecutara...
- La tercera es una accion que se realizara cada vez que termine el codigo de los corchetes...

Repasemos pues, la primero expresion que se pone en el parentesis es una accion que se ejecuta junto con la setencia for, la segunda es la condicion de toda la vida y la tercera es una accion que ocurre cada vez que se llega al final de la setencia for...

Pos bien, os estareis preguntando porque una expresion tan complicada. Para saberlo necesitaremos imaginacion y ver lo que esta en el parentesis:

(i = 0; i < 20; i++)

La orden del principio es que la variable i es igual a 0. La condicion es que i sea menor de 20. La primera que se ejecuta es cierto porque le hemos puesto que i es igual a 0... Y que yo sepa, 0 es menor que 20.

Pero que pasa con la tercera expresion?. Esta indica que cada vez que se llegue al final de la setencia for se le sume uno a la variable.

Bien, ahora imaginaos que sois la maquina. Llegais a la setencia for

for (int i = 0; i < 20; i++){
cout<<"Spam"<<endl;
}

Le dais a la variable i el valor de 0 y ejecutais el for, ya que i es menor que 20 ^^.

Escribís la primera línea de texto, llegais entonces al final del for, le sumais uno a la variable y volveis a comprobar que la condicion sea cierta. Es cierta porque 1 sigue siendo menor 20 asi que volveis a crear el sprite...

Esto se repite hasta que la variable i sea mayor que 20. Esto hace que el codigo se repite 20 veces (revisad lo que he dicho antes, en cada vuelta aumenta la variable en 1. Por tanto tarda 20 vueltas en llegar a 20).

Por tanto, lo que estamos haciendo es escribir 20 veces. Todo de una manera sencilla (cuando le cogeis el tranquillo, es muy facil) y rapida. Ademas ocupais menos codigo con eso que escribiendo 20 veces eso (ademas que es mas coñazo ^^).


3.3 Ejemplos prácticos

Pongamos algunos ejemplos prácticos de lo que hemos dado.

Imaginemos que queremos crear un programa que nos calculase el cuadrado de los numeros del 1 al N. Siendo N un número que nos introduce el usuario.

Lo primero sería guardar el número N en una variable:

int N;

cin>>N;

Y ahora tenemos que ir mostrando sus cuadrados... Como una sentencia que se repite un numero x de veces, lo mejor es usar un for. Que termine cuando lleguemos al numero N:

for (int Numero = 1; Numero <= N; Numero++)
{
cout<<Numero*Numero<<endl;
}

Empezamos desde el 1, y vamos haciendo operaciones y mostrandolas con el cout (si no ponemos comillas, el cout nos muestra el valor de una variable/operación). El proceso se repite hasta que pasamos al numero N:



Ahora supongamos que querremos crear un programa que nos calcule el salario de unos empleados. Dicho salario se paga así:

- Si el número de horas trabajadas es inferior a 20 se paga una cantidad fija de 240 euros.
- Si el número de horas trabajadas es superior a 20 entonces se paga un fijo de 260 euros + 15 euros por hora extra trabajada (número de horas que superen las 20h)

Basicamente, tenemos que poner con un if si las horas del empleado son 20 o más:

int horas,salario;
cin >> horas; // Leemos las horas

if (horas<20)
{
salario = 240; // Si trabaja menos de 20 horas, se le aplica el salario fijo
}
else
{ salario = 260 + horas * 15; // Si trabaja mas, se le aplica este salario
}

cout << salario; // Se muestra el salario por pantalla

Y esto es todo por hoy. Os animo a prácticar ejemplos e intentar crear algunos programas sencillos:

- Un programa que le indiques tu fecha de nacimiento, y te calcule tu edad.
- Un programa que le introduzcas dos numeros, y le puedas decir si lo sumas, lo restas, lo multriplicas o los divides.
- Un programa que te resuelva ecuaciones de segundo grado (recordamos que las ecuaciones de segundo grado se resolvían con una formulita).

Cualquier duda, consultadme.

4. Funciones

Empezamos ahora con las funciones, una cosa bastante básica a la hora de empezar a programar.

4.1 Definición

Las funciones son acciones programadas de antemano y que ejecutaremos cuando necesitemos.

Esta es la estructura de una funcion simple:

void Nombre_que_quieras(){

// El codigo que queramos

}

Es sencillo, todo el codigo que hay entre los corchetes { y }. Se guardan en la funcion Nombre_que_quieras.

De ahora en adelante si escribes Nombre_que_quieras(); se ejecutara el codigo que has puesto antes

He aquí, un ejemplo práctico. Cuando empiezas a trabajar con librerías gráficas, a veces tienes que usar lineas y líneas de código:

int depth, res;
allegro_init();
depth = desktop_color_depth();
if (depth == 0) depth = 32;
set_color_depth(depth);
res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, RESOLUCIONX,RESOLUCIONY, 0, 0);

if (res != 0) {
allegro_message(allegro_error);
exit(-1);
}

install_timer();
install_keyboard();
install_mouse();

Todo eso, para iniciar la librería gráfica... Lo cual es muy engorroso y muy feo, pero si lo metemos en una función:

void IniciarGraficos()
{
int depth, res;
allegro_init();
depth = desktop_color_depth();
if (depth == 0) depth = 32;
set_color_depth(depth);
res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, RESOLUCIONX,RESOLUCIONY, 0, 0);
if (res != 0) {
allegro_message(allegro_error);
exit(-1);
}

install_timer();
install_keyboard();
install_mouse();
}

Cada vez que pongamos "IniciarGráficos()" en el código, nos saldrá el codigo que hemos puesto aquí.

Es sencillo fácil, el problema es donde ponemos las declaraciones de las funciones... Yo recomiendo ponerlo abajo del todo, pero para que podamos hacer eso tenemos que poner los prototipos encima del main. Es decir, indicarle al programa que vaya reservando la memoria para la función, basicamente es escribir:

void IniciarGraficos();

Con eso debería cogertelo. Aquí os dejo un ejemplo:

#include <cstdlib>
#include <iostream>
#include <allegro.h> // Incluimos la libreria grafica

void IniciarGraficos(); // Prototipo

using namespace std;

int main(int argc, char *argv[])
{

InicializarGraficos();

system("PAUSE");
return EXIT_SUCCESS;
}

// Declaracion de la funcion

void IniciarGraficos()
{
int depth, res;
allegro_init();
depth = desktop_color_depth();
if (depth == 0) depth = 32;
set_color_depth(depth);
res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, RESOLUCIONX,RESOLUCIONY, 0, 0);
if (res != 0) {
allegro_message(allegro_error);
exit(-1);
}

install_timer();
install_keyboard();
install_mouse();
}

/* Nota: El codigo no compilara porque posiblemente no tengais la libreria Allegro, es solo un ejemplo de como se haría */

El funcionamiento siempre es el mismo, prototipo arriba y declaración abajo. Con eso podrás usar cualquier función.

4.2 Funciones Avanzadas (Paramétros)

[size=90]4.2.1 Usando Parametros Formales

[/size]Son las funciones en la que podemos meter datos e incluso nos lo pueden dar. Es una parte compleja de entender pero cuando lo aprendes es muy facil de usar, prestad atencion pues.

Veamos pues, este metodo que uso para hacer potencias:

int numero = 2;
int base = 2;
int exponente = 2;
int p = 1;

while (exponente > p){
numero *= base;
p++;
}

El metodo es sencillo, le ponemos un numero y las veces que lo queremos multriplicar (exponente). Multriplicamos el numero dichas veces y ya tenemos nuestra potencia.

Como veis esto es muy util, para tenerlo mas a mano podriamos usar una funcion:

void Potencia(){
int numero = 2;
int base = 2;
int exponente = 2;
int p = 1;

while (exponente > p){
numero *= base;
p++;
}
}

Cual es el problema?. Que la funcion Potencia(); hara la potencia de dos elevado al cuadrado (Porque es la que le hemos puesto) y ninguna otra mas.

No trae mucha cuenta pues. La idea seria que tu puedas meterle el numero y el exponente que quieras y que despues te devuelva la solucion.

Esa es la idea de las funciones que vamos a dar ahora.

Empezemos pues, os acordais de las variables?. Unas unidades que tenian un valor:

int cosa() = 2;

Sin embargo, que pasa si queremos que la variable tenga como valor el resultado de la suma de dos numeros?.

Para hacer ello, podemos que las variables sean el resultado de una accion. La accion la delititaremos con los corchetes { y }.

Veamos pues, como seria:

int numero = 2;
int cosa(){
numero += 2;
return numero;
}

Lo primero que hemos hecho es declarar una variable que usaremos a continuacion. Declaramos la variable cosa y establecemos una accion con los corchetes { y }.

La accion sera sumar 2 unidades a la variable numero. Despues, se devuelve la variable numero como resultado de la funcion.

Que quiere decir?. Pues que con la funcion return (devolver) damos el valor que adquiere la variable al final de la accion.

Digamos, que si pusieramos esto:

int cosa(){
return 2;
}

La variable cosa tendria un valor de 2.

Si pusieramos esto:

int numero = 2;
int cosa(){
return numero;
}

La variable cosa tendria valor 2, porque la variable numero tiene valor 2.

Como veis la funcion return devuelve el valor final que tendra la variable, sera lo ultimo que pondremos en las funciones que daremos mas adelante.

Volvamos pues al caso anterior:

int numero = 2;
int cosa(){
numero += 2;
ret urn numero;
}

Le sumamos 2 a la variable numero y despues devolvemos el valor de la variable numero. Hasta aqui bien, ¿No?.

A partir de entonces cuando usemos la variable cosa, se realizara la accion entre los corchetes para dar su valor.

Acciones programadas de antemano... ¿Os suena de algo?.

¡Funciones!. Tenemos una funcion que da el valor de la variable numero mas dos, y si la modificamos podemos hacer mas cosas. Como por ejemplo, que sea la suma de dos numeros partido entre dos (Una funcion que nos haga la media de toda la vida).

El modo de usarlo es igualito al de las funciones, aqui va un ejemplo:

Ya sabemos hacer funciones que nos devuelvan valores, pero aun no podemos meter los valores que queramos en nuestra funcion. Viene prestablecidos de antemano, por lo que pierden utilidad.

Aunque no lo parezca, resulta muy facil de hacer eso. Simplemente ponemos las variables que se van a usar para darles un valor.

Volviendo al ejemplo del principio:

int numero = 2;
int base = 2;
int exponente = 2;
int p = 1;

while (exponente > p){
numero *= base;
p++;
}

Primero expresamos eso en modo de funcion que ya conocemos:

int Potencia(){
int numero = 2;
int exponente = 2;
int p = 1;
int base = numero;
while (exponente > p){
numero *= numero;
p++;
}
return numero;
}

Ahora al menos nos da un valor como resultado, pero seguimos sin poder definir los numeros que queramos.

Para poder definirlos declararemos las variables DENTRO de los parentesis:

int Potencia(s32 numero, u8 exponente){
int p = 1;
int base = numero;
while (exponente >; p){
numero *= numero;
p++;
}
return numero;
}

Nota: La variable p no la he puesto en los parentesis porque no nos hace falta, debe ser siempre uno. La variable base tampoco la he puesto por la misma razon

Ok, declaramos pues la funcion de Potencia de dicha forma.

Y ahora cuando lo queramos usar debemos poner:

Potencia(valor de la variable numero, valor de la variable exponente);

Osease:

Potencia(el numero que quieres elevar, al exponente a lo que lo vayas a elevar);

Asi que, si quisiera hacer la potencia de 2 elevado a 2:

Potencia(2,2);

Si quisiera hacerlo de 4 elevado a 2:

Potencia(4,2);

De 3 elevado a 3:

Potencia(3,3);

Hemos hecho una funcion a la que le damos valores y nos da un solucion. Hemos dado las funciones avanzadas.

Como veis esto resulta muy util. Podemos usar la funcion Potencia como si fuera una variable (de hecho practicamente lo es) y hacer todas esas peripecias que haciamos antes con las variables.

Por último, decir que en los prototipos tenemos que indicar las variables que se pasan. Tenemos que indicarlas en el prototipo, aunque no es imprescindible indicar los nombres:

int Potencia(int,int);

4.2.2 Usando Paramétros pasados por referencia

El funcionamiento es parecido al anterior. Pero ahora, si modificamos una variable, se nos modificará de verdad.

Simplemente tenemos que indicarlo con un & al declarar la función (y en el prototipo).

int Potencia(int&,int&); // Prototipo

int Potencia(int &base,int &exponente) // Declaracion
{
tal y tal
}

Cualquier cambio que le hagamos a la variable dentro de la funcion, se reflejará en la variable original (en cambio si no le pones &, se reflejará lo contrario).

Y esto es todo por hoy. Podeis ir practicando creando funciones sencillas (por ejemplo, para sumar,restar... O para pintar un cuadrado de letras...). Id experimentado.

5. Vectores, Matrices y Estructuras

En este tutorial daremos los tipos de datos complejos y empezaremos ya con algunas cosas más prácticas. ¡Animo!

5.1 Vectores

[size=90]Son agrupaciones de dos o más variables. Basicamente, está para facilitar el trabajo con un gran grupo de variables.

Por ejemplo, imaginaos que tenemos 10 variables enteras:

[/size]

int variable1;
int variable2;
int variable3;
int variable3;
int variable4;
int variable5;
int variable6;
int variable7;
int variable8;
int variable9;
int variable10;

Muchas líneas de codigo para declararlas y no digamos para usarlas...

Para trabajar con grupos de variables similares, podemos usar los vectores (o array en nomenclatura Inglesa):

int variable[10];

La forma de declararlos es bastante similar a las variables normales, solo tenemos que poner entre corchetes el numero de variables que querremos.

Para acceder a una variable, es tan facil como poner su numero. Si quisieramos acceder a la variable 1:

variable[0];

// Los vectores empiezan a contar desde el numero 0

Para acceder a la variable 3:

variable[2];

// Recordamos que se empieza a contar desde el 0

Para acceder a la variable 10:

variable[9];

Cabe decir, que son 10 variables empezando a contar desde el 0. Luego serían del 0-9, el elemento [10] no existiría

He aquí, un ejemplo práctico. Queremos hacer un programa que recoja la Audencia de un programa a lo largo del día. Para ello le iremos introduciendo por teclado la audiencia de cada hora.

Tenemos que crear una variable por cada hora, de modo que usaremos un vector:

int Audiencia[24];

Por regla general, cada vez que declaramos una variable habría que inicializarla a un valor. Podemos hacerlo manualmente:

Audiencia[0] = 0;
Audiencia[1] = 0;
Audiencia[2] = 0;
Audiencia[3] = 0

...

Audiencia[22] = 0;
Audiencia[23] = 0;

// Recordamos que empieza a contar desde el 0!

Podemos hacerlo en formato de vector, es más bonito y ocupa menos codigo:

Audiencia = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

O podemos hacerlo con un bucle for. Muy útil si el tamaño del vector es muy grande:

for (int i = 0; i < 24; i++)
{
Audiencia = 0;
}

Al iniciar el for, declaramos la variable i y le damos valor 0. Despues declaramos la primera variable Audiencia[0].

En la siguiente repetición del for, la variable i ha cambiado. Ahora estamos trabajando con Audiencia[1].

Y asi sucesivamente hasta que llegamos al último elemento del vector, entonces salimos del bucle.

Podemos emplear un sistema similar para leer los datos:

for (int i = 0; i < 24; i++)
{
cout<<"Audiencia a las "<<i<<" : ";
cin>>Audiencia;
}

El funcionamiento es similar al anterior, en cada repeticion del for cambiará el valor de i. Luego estaremos adcediendo a los distintos valores de Audiencia.

Para hacer el programa más completo, también hemos añadido la variable i en el cout, para que nos vaya diciendo por donde vamos.

Ya tenemos los dos elementos fundamentales, ahora ponemos el codigo entero:

#include <iostream>
#include <stdlib.h>

using namespace std;

const int TAM = 24;

int main()
{

int Audiencia[24];
for (int i = 0; i < 24; i++)
{
Audiencia = 0;
}

for (int i = 0; i < 24; i++)
{
cout<<"Audiencia a las "<<i<<" : ";
cin>>Audiencia;
}
system("PAUSE");
return 1;
}

Podríamos ir más allá y juntar los bucles. Haciendo así el programa más eficiente:

#include <iostream>
#include <stdlib.h>

using namespace std;

const int TAM = 24;

int main()
{

int Audiencia[24];

for (int i = 0; i < 24; i++)
{
Audiencia = 0;
cout<<"Audiencia a las "<<i<<" : ";
cin>>Audiencia;
}

system("PAUSE");
return 1;
}

5.1.1 Vectores en Funciones (typedef)

Los vectores no están definidos como datos y no podemos pasarlos a funciones. Salvo que los definamos previamente usando el typedef

typedef int Vector[24];

Ahora tenemos definida la palabra Vector como tal, si queremos declarar un vector de 24 valores, solo tendremos que escribir:

Vector Audiencia;

Y ya estaría declarado. Ahora que tenemos definida la palabra Vector, podemos pasarlas a funciones:

void CalcularMedia(Vector Datos);

Le pasariamos el vector correspondiente a la función. Cabe decir, que aunque no pongamos un &, los vectores siempre se pasan por referencia. Es decir, si hacemos un cambio en el vector dentro de la función, dicho cambio se reflejará en el vector original

5.2 Matrices[size=90]

Son similares a los vectores, solo que tienen dos campos a rellenar:[/size]

int Variable[50][40];

Si queremos adceder al elemento 22,15:

Variable[21][14];

// Por ultima vez, empezamos a contar desde el 0!

Si queremos adceder al elemento 43,32:

Variable[42][31];

No tiene más misterio, también podemos crear matrices de más dimensiones:

int Variable[15][20][5];
int Variables[10][85][32][353][312];

El uso de las matrices es prácticamente identico a los vectores, tenemos que recordar a su vez que tenemos que definirlas con un typedef si queremos usarlas en funciones.

5.3 Estructuras

[size=90]Es una forma de objetos complejos que tienen distintos tipos de datos o campos.

[/size]Imaginad que estamos creando un juego de naves. Para mover las naves tendriamos que ir creando una variable por nave (posicion x,posicion y y la velocidad). En el caso de que hubiesen 2 habria que poner:

int x;
int y;
int velocidad;
int x2;
int y2;
int velocidad2;

Si ahora le añadimos otra nave mas:

int x;
int y;
int velocidad;
int x2;
int y2;
int velocidad2;
int x3;
int y3;
int velocidad3;

Esto no solo ocupa mucho codigo, sino que ademas es un verdadero coñazo. Y si ahora lo es, imaginaos cuando tengamos 20 naves.

Con las estructuras, podremos tener variables preparadas de antemano y asignarlas rapidamente cada vez que creemos otra nave.

Veamos, asi declarariamos una estructura:

struct // nombre de la estructura
{
// Variables a usar
};

Aplicada al ejemplo anterior:

struct Nave
{
int x;
int y;
int velocidad;
}; // Importante este punto y coma

Ahora tenemos todas las variables accesibles al alcance de la mano. Usar esta herramienta es bastante sencillo:

Nave Naveprincipal;

En donde pone "Nave" pondremos el nombre que le asignaremos a la estructura. Y en donde pone Naveprincipal, ponemos el nombre que queramos.

Ahora gracias a esto, tendremos declaradas todas las variables correspondientes a la nave principal:

Nave Naveprincipal;

// Obtenemos

Naveprincipal.x; // Adcedemos a la variable x
Naveprincipal.y; // Adcedemos a la variable y
Naveprincipal.velocidad; // Adcedemos a la variable Velocidad

// Los campos de una estructura se adceden con un punto

Podemos mezclar estructuras con vectores y nos saldría una cosa preciosa:

Nave Flota[100];

Ahora tenemos 100 naves diferentes guardadas, cada una con sus posiciones XY y su velocidad. El modo de usarlo no es muy distinto a lo que hemos visto:

Flota[3].X // Adcedemos a la variable x de la nave 4
Flota[2].Y // Adcedemos a la variable y de la nave 3

Y esto es todo por hoy, en el siguiente tutorial empezaremos ya con la práctica y nos dedicaremos más bien a los usos prácticos de todas estas cosas.

A los curiosos, os invito a usar los conocimientos que habeís adquirido con este tutorial para hacer un "hundir la flota". Las condiciones son:

Se crearán dos matrices con el campo de batalla (una para cada jugador):

1)Ambas matrices se rellenarán con el valor 0 (que simularán agua).
2) Por teclado se introducirán 5 posiciones por matriz que rellenaremos con el valor 1 (que
simularán los barcos).
3) Cada jugador realizará una jugada dando las coordenadas [i,j] de la matriz. Si la coordenada
tiene valor 1 pasará a 0 y se emitirá un mensaje de ‘hundido’. El primer jugador que
hunda toda la flota gana y termina el juego.
4) (Opcional) Ampliar el programa para que se presente un mensaje de ‘hundido’, sólo si una
posición marcada con true como barco no tiene vecinos (en sentido vertical u horizontal) que
tengan el valor 1 (se ha hundido el barco completo), en el resto de casos dirá ‘tocado’.[/quote]Aquí os dejo mi versión:
http://dl.dropbox.com/u/69551225/Hundir%20la%20Flota.ex

6. Como programar

Hoy, daremos conocimientos prácticos de lo que hemos dado. Sabemos que es una estructura o un Vector pero aún no sabemos para que nos pueden servir... En este tutorial haremos ejercicios prácticos en el que aplicaremos nuestros conocimientos aprendidos, también daremos una pequeña guía de "estilo" para programar.

6.1 Repaso de los conceptos básicos

Haremos un repaso del Tutorial 2.

Repasaremos como se hacen operaciones y el trato de variables. Aunque no es imprescindible, conviene haberte leído el tutorial 3 y saber como funcionan los if/else por lo menos.

6.1.1 Transformador de medidas

Se le meterá al programa, una medida en milimetros y nos devolvera ese valor en metros,centrimetros y milimetros... Por ejemplo, si se introduce como longitud: 2345, el programa mostrará como resultado: 2m, 34cm, 5mm.

El primer punto está claro, tenemos que crear una variable para guardar los milimetros y después leerla por teclado:

int Medida = 0;

cout<<"Introduce las medidas en milimetros: ";
cin>>Medida;

El siguiente paso, sería transformar la medida. Lo ideal, es pasarla primero a metros y lo que nos sobre ya lo vamos pasando a centrimetros. Creamos una variable para guardar los metros y la aplicamos:

int Medida = 0;
int Metros = 0;

cout<<"Introduce las medidas en milimetros: ";
cin>>Medida;

Metros = Medidas/1000;

El "resto" que nos sobrará de esa división, tendrémos que expresarlo en centrímetros. Creamos una variable para guardar los centrimetros y aplicamos:

int Medida = 0;
int Metros = 0;
int Centrimetros = 0;

cout<<"Introduce las medidas en milimetros: ";
cin>>Medida;

Metros = Medidas/1000;
Centrimetros = (Medidas%1000) /10

Recordamos que % es para que nos de el resto de una división (Medidas/1000). El resto está expresado en milimetros asi que dividimos entre 10.

El valor en milimetros de la medida, será el resto de la división anterior:

int Medida = 0;
int Metros = 0;
int Centrimetros = 0;
int Milimetros = 0;

cout<<"Introduce las medidas en milimetros: ";
cin>>Medida;

Metros = Medidas/1000;
Centrimetros = (Medidas%1000) /10
Milimetros = (Medidas%1000) %10

Después lo mostramos por pantalla y ya tenemos el programa hecho:

int Medida = 0;
int Metros = 0;
int Centrimetros = 0;
int Milimetros = 0;

cout<<"Introduce las medidas en milimetros: ";
cin>>Medida;

Metros = Medidas/1000;
Centrimetros = (Medidas%1000) /10
Milimetros = (Medidas%1000) %10

cout<<"Son "<<Metros<<" metros, "<<Centrimetros<<" centrimetros y "<<Milimetros<<" milimetros."

Notesé, que he ido interrrumpiendo el texto del cout para ir poniendo las variables. Está técnica es muy práctica y debeís intentar ponerla en práctica.

Hay miles de formas de abordar este ejercicio, si alguien no le ha quedado claro con esta. Puede intentarlo por su cuenta, aunque os cueste un poco tarde o temprano os saldrá <img class="inlineimg" src="http://www.espalteam.com/foros/images/smilies/wink.gif" border="0" />

Otra variedad de este ejercicio, es hacer un programa que calcule si un numero es divisible entre otro (necesitarás la sentencia condicional if y la operación % del resto).

if (Dividendo % Divisor == 0)
// Divisible

else //No divisible

6.1.2 Programa que te calcule la edad

Un programa que podeís hacer y que se comentó en el tutorial 3. Es un programa que te calcule la edad a partir de tu fecha de nacimiento.

Lo primero que habría que hacer es pedir los 3 datos y guardarlos en tres variable:

int Dia = 0;
int Mes = 0;
int Anyo = 0;

cout<<"Introduce tu dia de nacimiento: ";
cin>>Dia;
cout<<"Introduce tu mes de nacimiento: ";
cin>>Mes;
cout<<"Introduce tu anyo de nacimiento: ";
cin>>Anyo;

Si quereís ir más allá, las variables se podrían guardar en una estructura llamada Fecha:

// Declaracion Estructura
struct Fecha
{
int Dia;
int Mes;
int Anyo;
}

Fecha Nacimiento; // Creamos una estructura

cout<<"Introduce tu dia de nacimiento: ";
cin>>Nacimiento.Dia;
cout<<"Introduce tu mes de nacimiento: ";
cin>>Nacimiento.Mes;
cout<<"Introduce tu anyo de nacimiento: ";
cin>>Nacimiento.Anyo;

Restando el año actual (2012) al año de nacimiento tendríamos la edad. Luego se puede comprobar si se ha cumplido ya los años o los cumple más tarde, si aún no lo ha cumplido tendríamos que restar en 1 la edad.

La comparación es tan fácil como:

if (MesActual < Mes) // No lo ha cumplido

Si el mes fuese el mismo, habría que hacer la comparación con los días.

6.1.3 Programa que resuelva Ecuaciones de Segundo Grado

Este también es un programa típico que se suele pedir en las primeras clases de programación en la Universidad.

Todo el mundo sabe que las ecuaciones de Segundo Grado se componen de:

ax^2+bx+c = 0

Si nos dan A,B y C. Podemos dar la solución con una formulita:



Podemos aplicar esa formulita en programación, solo tenemos que declarar las variables A,B,C y hacer las operaciones que tenemos ahí.

PD: Para realizar raices tendremos que incluir la librería Matemática, para lo cual pondremos al principio del codigo: #include <math.h>

Una vez incluida, usaremos la función sqrt(numero) para realizar la raíz.

6.2 Uso práctico de las estructuras condicionales

Haremos un repaso del tutorial 3.

Tenemos las setencias if,else y switch. Para representar condiciones, también tenemos sentencias repetitivas (while, do while y for).

Para no complicarnos la vida, haremos un uso práctico de ellas en programas matemáticos. Pues son los más fáciles de implementar en programación. Empezaremos por un programa que nos transforme unidades.

6.2.1 Alquileres de coches

Tenemos el siguiente planteamiento:

Hay que realizar un programa que calcule el coste del alquiler de un vehículo a partir del número de días que se alquila (dato de entrada). El precio varía en función del número de días de la siguiente forma:

Si se alquila 1 día, el precio es de 80 euros.
Si se alquila 2 días, el precio es de 60 euros por día.
Si se alquila de 3 a 4 días, el precio es de 50 euros por día.
Si se alquila de 5 a 7 días, el precio es de 40 euros por día.
En caso de alquilarse más de una semana, el precio es de 30 euros por día.

Multiples alternativas dependiendo de la condición... Lo más fácil es aplicar una sentencia switch:

int Precio = 0;

// Leemos los dias
int Dias = 0;

cin>>Dias;

switch (Dias)
{

case 1:
Precio = Dias*80;
break;

case 2:
Precio = Dias*60;
break;

case 3: // El precio es el mismo para los alquileres de 3-4 dias, los ponemos //juntos
case 4:

Precio = Dias*50;
break;

case 5: // Similar al caso anterior (5-7 dias).
case 6:
case 7:

Precio = Dias *40;
break;

default:
Precio = Dias * 30;
break;

}

cout<<"El precio es de "<<precio<<" por "<<Dias<<" dias alquilados;

No creo que tenga demasiada complicación, pero si alguien tiene alguna duda que pregunte.

6.2.2 Tienda de Comercio eléctronico

Una tienda de comercio electrónico realiza un descuento a sus clientes en relación a la importancia de la compra. He aquí la tabla de descuentos que aplica:

Gasto Descuento

C < 1000 10%
1000 ≤ C < 2000 15%
2000 ≤ C < 4000 20%
C ≥ 4000 25%

Implementa un programa que muestre el total a pagar a partir del gasto realizado por el cliente.

Es identico al de los coches. Si alguien tiene alguna duda que pregunte

6.2.3 El numero de Euler

El número de Euler e se puede obtener a partir de la siguiente serie:

2+1/(1*2)+1/(1*2*3)+1/(1*2*3*4)...

Escribe un programa que calcule una aproximación de e utilizando tan sólo 6 elementos de la serie (dos elementos más de los que aparecen descritos en la fórmula anterior). Comprueba que el resultado de la aproximación es 2.71806.

Tengo que retirarme por un tiempo, cuando vuelva pondré la solución a este problema (no es fácil). Y seguiré con el tutorial.

También espero poner las capturas de los programas de antes (no tengo el compilador a mano y no he podido hacerlas).</p>