Curso de C++

Curso de C++
¡Bienvenidos a mi curso de C++!, en realidad esto es sólo una sección del blog donde pueden
consultar una serie de posts que ya había hecho anteriormente, pero de un forma ordenada,
empezamos desde lo más básico y vamos avanzando poco a poco. Yo se que es muy fácil
darle clic a ‘Siguiente’, pero si de verdad quieren aprender no lo hagan hasta que hayan
comprendido el post y hayan hecho alguna práctica sobre ello.
Recuerden que en el curso no están todos los posts del blog, si alguna entrada les pareció
interesante pueden checar los posts relacionados (abajo de cada post) para leer otros posts
del mismo tema. Y creo que no están ordenados muy muy bien, pero creo que eso ayuda un
poco a hacer menos monótono el aprendizaje :)
Así que aquí abajo está el índice, o pueden dar clic en siguiente (aquí en la barra lateral ->)
para comenzar desde el primero; iré agregando más temas de vez en cuando.
Posts Relacionados
 Entendiendo los ciclos en c++
 Condiciones (decisiones) en C++ – if, else
 Como usar ciclo While en C++
 Funciones en C++
Curso de C++
 Curso de C++
 Hola Mundo, en C++
 Comentarios en C++
 Variables en C++ 1 – Lo básico
 Variables en C++ 2 – Mostrar variables
 Operaciones en C++
 Operadores lógicos en C++
 Pedir datos en C++ – scanf()
 Condiciones (decisiones) en C++ – if, else
 Entendiendo los ciclos en c++
 Ciclos for en C++
 if else anidados en c++
 El break y el ciclo infinito
 Como usar ciclo While en C++
 Cómo empezar a usar iostream
 Introducción a string.h
 Como usar cin.getline en C++
 Funciones en C++
 Tipos de funciones en C++
 Operadores compuestos en C++
 Cuando inicializar las variables en cero y cuando no
 #define en C++, cómo sí y cómo no
Diferencias entre C y C++
Me han estado llegando comentarios y correos con dudas, correcciones y todo tipo de
insultos (no, eso último no) y decidí responder todos ellos con este post en el que aclararé lo
que es C y lo que es C++ y sus diferencias.
C fue creado en 1972 por Dennis M. Ritchie en los Laboratorios Bell como evolución del
anterior lenguaje B, a su vez basado en BCPL.
C++, por su parte, fue creado a mediados de los años 1980 por Bjarne Stroustrup. La
intención de su creación fue el extender al exitoso lenguaje de programación C con
mecanismos que permitan la manipulación de objetos.
Así que C es el lenguaje original, mientras que C++ es una ampliación de C, por eso el ++.
A mí cuando me enseñaron a programar me dijeron que iba a aprender a programar en C++,

pero en verdad me enseñaron únicamente C, así que muchos profesores en realidad no saben
lo que es programar en C++. Veamos un hola mundo en los dos programas:
En C
1#include<stdio.h>
2
3int main()
4{
5 printf ("Hola Mundo");
6 return 0;
7}
En C++
1#include<iostream>
2
3using namespace std;
4
5int main()
6{
7 cout << "Hola mundo";
8 return 0;
9}
Para el tipo de programas que se estarán mostrando en este blog la diferencia más
importante es la entrada y salida de datos. Así que veamos un ejemplo de entrada y salida
de datos de cada programa:
En C
1#include<stdio.h>
2
3int main()
4{
5 int radio;
6 float area, perimetro;
7
8 // SALIDA: mensaje un pantalla
9 printf("Introduce el radio del circulo: ");
10
11 //ENTRADA: recibir dato desde teclado
12 scanf("%d", &radio);
13
14 // calculos
15 area = 3.1416 * radio * radio;
16 perimetro = 3.1416 * radio * 2;
17
18 //SALIDA: resultado en pantalla
19 printf("El area es %.2f y el perimetro %.2f", area, perimetro);
20 getch();
21
22
return 0;
23
}
En C++
1#include<iostream>
3
4int main()
5{
6 int radio;
7 float area, perimetro;
8
9 // SALIDA: mensaje un pantalla
10 cout << "Introduce el radio del circulo: ";
11
12 //ENTRADA: recibir dato desde teclado
13 cin >> radio;
14
15
// calculos
16
area = 3.1416 * radio * radio;
17
perimetro = 3.1416 * radio * 2;
18
19
//SALIDA: resultado en pantalla
20
cout << "El area es " << area << " y el perimetro " << perimetro;
21
cin.get();cin.get();
22
23
24 return 0;
}
Lo que noté al hacer estos dos programitas es que pedir un dato en C++ es mucho más simple
que en C. Sin embargo, el asunto de los << y >> puede llegar a ‘asustar’ a los recién iniciados
en la programación.
Pedir un dato en C
scanf("modificador", &nombre de la variable);
Pedir un dato en C++

cin >> nombre de la variable;
Mostrar un dato en C
printf("Dato: modificador", nombre de la variable);
Mostrar un dato en C++

cout << "Dato: " << nombre de la variable;
Los modificadores son los siguientes: %d para int, %f para float, %s para string, %c para char.
Librerías en C++
Por simple convención las librerías en C terminan en ‘.h’ (punto hache). Todas las librerías
de C sirven para C++, sin embargo, también por convención, se elimina la terminación ‘.h’ y
mejor se agrega ‘c’ al principio.
Libreria en C Librería en C++
math.h cmath
string.h cstring
time.h ctime
etcetera.
El ‘namespace’
C como lenguaje tiene un conjunto de palabras reservadas, como por ejemplo: if, for, while,
int, float, … C++ es una ampliación, por lo tanto tiene que agregar nuevas palabras
reservadas. Éstas palabras reservadas están en un ‘namespace’ (espacio de nombres). En
específico cout y cin están el namespace std (standard).
Si no declaráramos que vamos a usar el namespace std (using namespace std;), cada vez que
quisiéramos usar cout, tendríamos que escribir std::cout.
Espero que a partir de ahora pueden identificar si un programa está en C o en C++. También
espero estar publicando mis programas en ambos lenguajes a partir de ahora.
#define en C++, cómo sí y cómo no

El mayor objetivo de este post es darles a conocer una de las cosas que C++ permite hacer
pero que nadie en su sano juicio debería de hacer. ¿Y para que se los enseño entonces? Pues
para que si algún día lo ven en un código ajeno sepan qué pinch_ está pasando.
Bueno, antes que nada, #define sirve para dos cosas: definir una constante o crear un
macro. Los macros pueden llegar a ser algo difícil de entender, ahora sólo veremos el asunto
de las constantes. El asunto aquí es que si yo pongo (fuera del main) una línea así:
#define PI 3.14159265
…significa que cada vez que escribamos PI en nuestro programa, C++ lo interpretará como
3.14159265. Es una simple sustitución.
#define <aquí va el nombre> <después de un espacio va el valor>
Pero el asunto es que se puedes hacer algunas cosas bastantes feas con esta propiedad. Vean
este programa:
1#include<iostream>
3
4#define PI 3.14159265
5#define NOF_CHAR 50
6#define pause cin.get();cin.get();
7#define ct cout
8#define cn cin
9#define false true
10
11int main()
12{
13 char name[NOF_CHAR] = {0};
14 ct << "Enter your name: ";
15 cn >> name;
16 ct << "Bye " << name << "." << endl;
17 if(false)
18 ct << "P.S. Pi = " << PI;
19 pause
20}
Tenemos 6 definiciones, ordenadas en su nivel de aceptabilidad:
 #define PI 3.14159265 y #define NOF_CHAR 50, éstos ejemplifican el uso

primario de #define: guardan un valor que es constante durante toda la ejecución del
programa.
 #define pause cin.get();cin.get();, ésta ya empieza a ser no aceptable pero
podemos darla por buena porque nos ayuda a leer mejor nuestro código. Ya sabemos
que al escribir cin.get();cin.get(); nuestro programa se pausa al igual que con un
getch(), pero al usar este #define escribiremos en lugar de eso simplemente pause.
 #define ct cout y #define cn cin, totalmente inaceptables. Algunas personas
usan este tipo de #define’s para escribir menos, pero de verdad que (en la gran
mayoría de los casos) no vale la pena el ahorro de caracteres, sólo estamos haciendo
nuestro código menos entendible para otras personas.
 #define false true, este es más bien como una broma (y es increíble que
funcione en verdad), pero si se usa en serio es como una rayada de madre. Si
ejecutan el código verán que sí se muestra la línea donde se imprime PI aún que está
dentro de un if al que nunca se debería de entrar ¿y por qué sí entra? porque false es
true.
Así que ya saben cómo sí y cómo no usar un #define en C++, y ya no están ‘indefensos’
ante programadores con malos hábitos.
Nuevo: Curso de C++

Según Google Analytics están regresando las visitas, que raro que coincida con el inicio de
clases ¿verdad? :D pero bueno, afortunadamente yo sí me preocupe por este blog en
vacaciones.
Como ya repetí dos veces, esto es un blog, lo que significa que los posts más recientes son
los que aparecen al principio. Además, cuando inicié este blog mi propósito era ir avanzando
en dificultad conforme al tiempo, no lo he cumplido mucho pero aun así los posts sobre los
temas más básicos están ‘enterrados’ debajo de los más recientes. Así que me tomé un
tiempo para echarme un clavado de panza en el Codex de WordPress y crear una forma
diferente de navegar en el blog.
Entonces así es como inauguro (siendo las 19:30 del dia… ah no verdad?) el Curso de C++.
Todo lo que tienen que hacer es ir a este índice y comenzar a leer: Curso de C++, Índice.
Luego pueden simplemente dar clic en el link ‘Siguiente’ que aparecerá en la barra lateral (-
>).
Así que espero que les sea de utilidad, si les gusta presúmanlo, si tienen un amigo que
siempre les anda preguntando pues mándenlo aquí y líbrense de él.
Code::Blocks, un IDE moderno para C++

Yo hace un buen rato que no uso Dev-C++ para programar, y sin embargo vi que aquí en la
barra lateral aún está el link hacia el post donde se los recomiendo. Así que ahora les voy a
recomendar el IDE que uso actualmente Code::Blocks.
Code::Blocks tiene bastante ventajas respecto a otros IDES:
 Aspecto moderno. ¿A quién le gusta programar a pantalla completa en consola

con fuente amarilla sobre fondo azul hoy en día?
 Multiplataforma. Windows XP/Vista/7, Mac OS X, Linux.
 Rápido. Está escrito en C++.
 Open Source. Eso significa muchas cosas, pero lo importante es que es gratis.
 Pestañas. Puedes tener muchos archivos abiertos.
Lo pueden descargar aquí: Download Code::Blocks. Asegúrense de descargar la versión que

trae el compilador incluido, el que dice mingw.
Si de plano nunca han manejado este tipo de software, tal vez les sean útiles estos consejos:
 Para hacer un programa pequeño (lo que sea que no necesite más de dos
archivos) no se compliquen creando proyectos. Simplemente vayan a: File/New/Empy
File. Luego guarden el archivo con extensión .cpp, preferentemente antes de
empezar a programar (si no lo guardan no tendrán diferentes colores en su código
(Sintax Highlighting)).
 Hay tres botones relacionados con ‘correr’ el programa: Build, Run y Build and
Run. El primero solo construye el programa pero no lo corre, el segundo solo lo corre
y el tercero los construye y los corre. Así que cuando queramos probar nuestro
programa el botón indicado es Build and Run, pero si no hemos hecho ningún cambio
y queremos volver a probarlo es más rápido Run.
Aprender inglés, ¿¡en C++!?

Me contó SetRoot a través de un comentario que se le ocurrió hacer un programa en C++ que
nos ayudará a aprender palabras en inglés, en sus propias palabras:
Se me ocurrió hacer un programa para aprender inglés y creo que los tiros también van por
ahí corrígeme:
1 llenar 1000 palabras
2 agruparlas por alguna relación como emociones artículos y otros (para esto quisiera usar
una matriz para acceder a ella más fácil aunque 2 matrices también creo q me van :s con
punteros y eso ,s)
3 ejecución: con un par de cases hacer un menú que me permita lanzar 20 palabras al
azar(con sran o ran creo + time) con su significado
y después que me permita hacer un tipo de examen o test con esas mismas palabras
desordenadas que cada acierto valga algo para ganar puntos y así involucrar a los amigos y
familiares
Me gustó la idea de hacer un pequeño ‘bosquejo’ de su idea porque precisamente se necesita
usar el código de mi último post: Números aleatorios sin repetir en C++. Así que mi algoritmo
es algo así:
1. Crear una matriz tipo string de N filas y 2 columnas, la primera columna son las
palabras en inglés; la segunda, en español.
2. Pedir el número de palabras que el usuario quiera memorizar.
3. Obtener ese número de palabras aleatoriamente y mostrarlas.
4. Borrar las palabras y empezar a preguntar el significado de cada una.
5. Comparar la respuesta del usuario con la respuesta correcta.
6. Calcular su calificación y mostrarla.
El código es este:
1#include<cstdlib>
2#include<ctime>
3#include<iostream>
5
6int nofw;
7#define N 8 // número de pares de palabras en la matriz
8
9bool checkrep(int n, int num[])
1{
0 for(int i=0; i<nofw; i++)
1 if(n == num[i])
1 return true;
1 return false;
2}
1
3int main()
1{
4 srand(time(NULL));
1 string ans, words[N][2] = {{"hi", "hola"}, {"house", "casa"}, {"water", "agua"},
5 {"roof", "techo"}, {"chair", "silla"}, {"loudspeaker", "bocina"},
1 {"screen", "pantalla"}, {"money", "dinero"}};
6 int n, correct=0, wrong=0;
1 cout << "Numero de palabras?: "; cin >> nofw;
7 // obtener 'nofw' palabras aleatoriamente de nuestra matriz
1 int num[nofw];
1 {
9 do
2 n = rand() % N;
0 while(checkrep(n, num));
2 num[i] = n;
1 cout << words[n][0] << " -> " << words[n][1] << endl;
2 }
2 cin.get(); cin.get();
2 system("cls");
3 // preguntar el significado de cada palabra
4 {
2 cout << words[num[i]][0] << " = "; cin >> ans;
5 if(ans == words[num[i]][1])
2 {
6 correct++;
2 cout << ">> Bien :)\n\n";
7 }
2 else
8 {
2 wrong++;
9 cout << ">> Mal :(\n\n";
3 }
0 }
3 cout << "Tuviste un " << (float)correct / (float)nofw * 100 <<
1 "% de respuestas correctas.";
3 cin.get(); cin.get();
2}
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1
4
2
4
3
4
4
4
5
4
6
4
7
4
8
4
9
5
0
5
1
5
2
5
3
5
4
5
5
Como dije antes, es sólo un bosquejo, pero tal vez sea el punto de partida para un buen
proyecto. Para optimizarlo creo que se deberían agregar algunas cosas:
 Obtener los pares de palabras desde una base de datos

 Ordenarlas por categorías
 Que no importe si la respuesta está en mayúsculas o minúsculas
 Mejorar la interacción con el usuario
Números aleatorios sin repetir en C++

Ya hemos visto cómo obtener número aleatorios en c++, pero tarde o temprano surge la
necesidad de generar números aleatorios pero sin que se repitan. Podría ser útil para
varias cosas como por ejemplo, ordenar de manera aleatoria elementos de una lista, formas
grupos aleatorios, barajear cartas, etc. Así que en algoritmo quedaría algo así:
1. Crear una matriz y dejarla vacía.

2. Obtener un número aleatorio.
3. Checar si ese número existe en la matriz. Si si, regresar al paso 2. Si no, guardar
el número en la matriz.
Así que el programa es este:

1#include<cstdlib>
2#include<ctime>
3#include<iostream>
5
6bool checkrep(int n, int num[])
7{
8 for(int i=0; i<10; i++)
9 if(n == num[i])
10 return true;
11 return false;
12}
13
14int main()
15{
17 int n, num[10];
18 for(int i=0; i<10; i++)
19 {
20 do
21 n = 1 + rand() % 10;
22 while(checkrep(n, num));
23 num[i] = n;
24 cout << num[i] << " ";
25 }
26}
Primero que nada, <cstdlib> es la forma correcta de incluir la librería <stdlib.h> en c++,
igual con <ctime>.
Como ven, usamos una función bool (que retorna falso o verdadero) para checar si el
número aleatorio ya existe en nuestra matriz. Si cualquiera de los números es igual a nuestro
número aleatorio n, la función retorna true, por lo que el ciclo do-while desde el cual
llamamos la función tendrá que repetirse una vez más y hasta que la función retorne false.
Cuando se logra salir del ciclo do-while, guardamos nuestra n en el lugar de la matriz que
corresponda, lo mostramos en pantalla y continuamos con la siguiente posición de la matriz.
Otra cosa. Para decirnos si un número está repetido en la matriz, la función checkrep()
necesita obviamente dos cosas, el número aleatorio y la matriz. Así que le enviamos como
parámetros nuestra matriz y nuestro número aleatorio.
Devolver cambio en C++
¿Han pagado algún recibo en una máquina automática y se han preguntado cómo será el
programa que les devuelve el cambio? Lo más seguro es que no, pero pues resulta que el
profesor de Miguel Ángel le encargó un programa que simulara eso, en sus propias palabras:
“Supón que una máquina de monedas de 10,5,2,1 y 50 centavos. Debes escribir un programa
que decida cuantas monedas dará de cambio, dando prioridad las de mayor denominación.
Debe recibir como entrada la cantidad de dar a cambio. Ejemplo: para $40.50 será 4 de 10,
0 de 5, 0 de 2, 0 de 1 y 1 de 50 centavos.”
Así que el primer problema se presenta con la entrada ¿cómo hacer que el usuario introduzca
sólo cantidades como $50 o $43.50 y no cantidades como $23.45 o $9.70?
Lo que se me ocurrió es pedir la cantidad en una variable float (cambio), en otra variable
convertir esa cantidad a tipo int (cambioint). En ese proceso se perderá la parte decimal del
número, así que si la resta cambio – cambioint es igual a 0 o igual a 0.50, la cantidad que
introdujo el usuario es correcta.
La otra parte es sencilla, sólo se necesita ver si la variable cambio es mayor que 10. Si, se le
restan 10 a la variable y se aumenta un contador. Luego se hace lo mismo con las demás
monedas.
Pero bueno, el programa es este:

1#include<iostream>
3
4int main()
5{
6 float cambio; int cambioint, m10=0, m5=0, m2=0, m1=0, m50c=0;
7 do
8 {
9 cout << "Cambio?: "; cin >> cambio;
10 cambioint = (int)cambio;
11 }while((cambio - cambioint) != 0 && (cambio - cambioint) != 0.50);
12 while(cambio != 0)
13 {
14 if(cambio>=10)
15 {
16 m10++;
17 cambio-=10;
18 }
19 else if(cambio>=5)
20 {
21 m5++;
22 cambio-=5;
23 }
25 {
26 m2++;
27 cambio-=2;
28 }
30 {
31 m1++;
32 cambio-=1;
33 }
34 else if(cambio>=0.5)
35 {
36 m50c++;
37 cambio-=0.5;
38 }
39 }
40 cout << m10 << ", " << m5 << ", " << m2 << ", " << m1 << ", " << m50c;
41}
Solo le faltaría darle un poco de formato a la salida, pero pues ya es cuestión de gustos y ya
saben, cualquier duda aquí están los comentarios abajo.
Cuando inicializar las variables en cero y cuando no

Cuando empecé a aprender a programar en c++ (creo que uno nunca acaba) me enseñaron
que siempre hay que inicializar en cero o en algún otro valor las variables, porque si no,
pueden tomar valores raros que podrían arruinar nuestro programa.
Vamos a ver si la leyenda es cierta:

1#include<iostream>
3
4int main()
5{
6 int var1;
7 cout << var1;
8}
Pues con mi compilador sí lo es, una variable sin inicializar toma valores raros. Pero si se han
fijado en mis programas, yo no siempre inicializo mis variables, ¿por qué? Pues porque no
siempre es necesario.
La regla es bastante simple: “Si la primera instrucción en la que usamos nuestra variable es
de asignación, no es necesario inicializarla.” Por ejemplo:
cin >> var1; // no es necesario inicializarla
var2 = 14; // no es necesario inicializarla
cout << var3; // es necesario inicializarla
var4 = cos(45); // no es necesario inicializarla
var5++; // es necesario inicializarla
if(var6 != 7) // es necesario inicializarla
cin.getline(var7); // no es necesario inicializarla
Podemos seguir inicializando todas las variables que usemos, pero si únicamente
inicializamos las necesarias vamos a dar la impresión de que sabemos lo que estamos
haciendo XD
Simular una Progress Bar en C++

Una progress bar es la barrita, generalmente verde, que aparece en sistemas operativos e
infinidad de programas cuando algo se está cargando. Hoy no nos vamos a meter en asuntos
de cargar archivos o algo, únicamente vamos a ver el principio básico sobre el que operan
estas barras.
Nuestro programa sólo pedirá una cantidad en segundos, que será el tiempo que durará en
llenarse nuestra progress bar. A la ventana donde se ejecutan nuestros programas le caben
80 caracteres de largo, así que vamos a decir que nuestra progress bar tiene una resolución
de 80. El único problema es saber cuánto durará cada unidad de esas 80 para que en total se
acumule el tiempo indicado.
La función delay() o Sleep()

Si en su IDE pueden usar la librería conio.h, entonces van a usar la función delay(). Si no,
vamos a tener que agregar la librería windows.h y usar la función Sleep() (así con
mayúscula).
Ambas funciones hacen exactamente lo mismo: paran el programa durante una cierta
cantidad de tiempo en milisegundos. Por ejemplo:
cout << "Hola" << endl;

Sleep(2000);
cout << "Hace dos segundos te saludé!";
Se muestra 'Hola', se pausa 2 segundos y se muestra 'Hace dos segundos te saludé!'

Para los que usan conio.h, sería algo así:
printf("Hola\n");
delay(2000);
printf("Hace dos segundos te saludé!");
Ahora sí, para saber cuánto tiempo durará cada unidad de nuestra barra tenemos primero
que convertir los segundos a milisegundos (s*1000), luego dividirlos entre la resolución de la
barra (s*1000/80). Así que nuestro programa queda así:
1#include<windows.h>
2#include<iostream>
4
5int main()
6{
7 int s;
8 cout << "Segundos?: "; cin >> s;
9 for(int i=0; i<=79; i++)
10 cout << "_";
11 for(int i=0; i<=79; i++)
12 {
13 cout << "=";
14 Sleep(s*1000/80);
15 }
16}
El primer ciclo es solo por estética, para ver hasta dónde va a llenar la barra. El segundo es
el que imprime la barra con sus respectivas pausas.
Saber si es palíndromo o no, de forma recursiva 2da

parte
Pues la idea que se me ocurrió en el otro post resultó ser más sencilla de lo que me imaginé,
y ahora sí la función recursiva se ve mucho mejor, ya es mucho más que un ciclo disfrazado.
Comenté extensivamente el código, así que aquí está:

1#include<string.h>
2#include<iostream>
4int len, n=0;
5
6string chk4palindrosity(string thestr)
7{
8 if(thestr[0] == thestr[thestr.length() - 1]) // comparar primer caracter
9con ultimo
10 {
11 n++;
12 if(n == len / 2) // si el numero de veces que la comparación ha sido
13cierta es...
14 return "Si es palindromo!"; // igual a la mitad de los caracters,
15es palindromo
16 thestr.erase(0, 1); // borramos primer caracter
17 thestr.erase(thestr.length() - 1, 1); // borramos ultimo
18 return chk4palindrosity(thestr); // llamamos a la función con el string
19recortado
20 }
21 else // si una de las comparaciones no es cierta, no es palíndromo
22 return "No es palindromo";
23}
24
25int main()
26{
27 char inputf[50]={0}, input[50], *parte;
28 cout<<"Introduce un palindromo: "; cin.getline(input, '\n');
29
30 parte = strtok(input, " "); //
31 strcat(inputf, parte); //
32 while((parte = strtok(NULL, " ")) != NULL) //
33 strcat(inputf, parte); // quitar espacios del array
34
35 string thestr(inputf); // convertir array en string para facilitar
36operaciones
37 len = thestr.length(); // obtener longuitud del string
38 if(len == 1)
cout << "Si es palindromo!";
else
cout << chk4palindrosity(thestr); // llamar a la funcion e imprimir lo
que retorne
cin.get();
}
Lo que hace la función recursiva es comparar el primer caracter con el último, si son iguales
recortarlos y llamarse; si no, no es palíndromo. Cualquier duda ya saben que los comentarios
están abiertos.
Saber si es palíndromo o no, de forma recursiva

Hace unos días me pidieron por correo un programa que nos dijera si un string es palíndromo
o no, pero usando una función recursiva. Me pareció interesante aunque raro que pidieran
hacerlo de forma recursiva.
Tal vez recuerden que ya había publicado aquí una forma de saber si un string es palíndromo
o no, el cual he descubierto (ahora que hice este otro) que no es muy eficiente.
Bueno pues el código es este:

1#include<string.h>
2#include<iostream>
4char cadenaf[50]={0}; int len, n=0;
5
6string chk4palindrosity(int c)
7{
8 if(cadenaf[c] == cadenaf[len-1-c])
9 {
10 n++;
11 if(n == len/2)
12 return "Si es palindromo!";
13 return chk4palindrosity(c+1);
14 }
15 else
16 return "No es palindromo";
17}
18
19int main()
20{
21 char cadena[50],*parte;
22 cout<<"Introduce un palindromo: "; cin.getline(cadena,50,'\n');
23
24 parte = strtok(cadena," "); //
25 strcat(cadenaf,parte); //
26 while((parte = strtok(NULL," ")) != NULL) //
27 strcat(cadenaf,parte); // quitar espacios del string
28
29 len = strlen(cadenaf);
30 cout << chk4palindrosity(0);
31 cin.get();
32}
La verdad es que es la función es recursiva de puro milagro. Lo que hice fue transformar el
ciclo que checaba que los caracteres fueran iguales en una función en la que se aumenta una
variable cada vez que se llama a sí misma.
El código ahora es más eficiente por dos simples razones:
1. Se detiene y da el resultado a la primera comparación de caracteres que no sean

iguales. Si el primer y el último carácter no son iguales, no es palíndromo y ya no
sigue analizando los demás.
2. Sólo checa la mitad de los caracteres. Si la mitad de los caracteres corresponden
a la configuración de un palíndromo, ya no hay porqué seguir analizando la otra
mitad.
Tal vez una mejor manera de hacerlo sería con una función que recibiera el string a analizar,
comparar el primer y último carácter: si no, no es; si si, eliminar el primer y último carácter
y volver a llamar a la función. Esto hasta que el número de comparaciones ciertas sea igual a
la mitad de la longitud inicial del string. ¿Alguien se anima a hacerlo?
Imprimir determinados números primos

Sobre números primos he escrito bastantes programas y me he dado cuenta de que los
profesores de programación tienen cierta fijación con ellos. Pero bueno, el programa de hoy
imprime la cantidad de números primos que el usuario quiera y es interesante porque es un
buen ejemplo de la utilidad de los ciclos infinitos, que ya habíamos visto antes.
Ok, el código es este:

1#include<iostream>
3
4int main()
5{
6 int cnt,i=0,ii,res,nc=0,np=0;
7 cout << "Introduce la cantidad de numeros: "; cin >> cnt;
8 for(;;)
9 {
10 i++;
11 for(ii=1;ii<=i;ii++)
12 {
13 res=i%ii;
14 if(res==0)
15 nc=nc+1;
16 }
17 if(nc==2)
18 {
19 cout << i << " ";
20 np++;
21 }
22 nc=0;
23 if(np==cnt)
24 break;
25 }
26}
Si tienen problemas para entender cómo obtuvimos los números primos, deberían darle una
revisada a estos posts: Saber si es primo o no y Primos en un rango.
Lo que hicimos es que todo el programa estuviera dentro de un ciclo infinito que se detendrá
cuando nuestra variable que se aumenta cada vez que obtenemos un numero primo np sea
igual a la variable con la cantidad deseada de números primos cnt.
Pero recuerden que donde podemos usar un ciclo infinito, queda mucho mejor un ciclo
while:
1#include<iostream>
3
4int main()
5{
6 int cnt,i=0,ii,res,nc=0,np=0;
7 cout << "Introduce la cantidad de numeros: "; cin >> cnt;
8 while(np!=cnt)
9 {
10 i++;
11 for(ii=1;ii<=i;ii++)
12 {
13 res=i%ii;
14 if(res==0)
15 nc=nc+1;
16 }
17 if(nc==2)
18 {
19 cout << i << " ";
20 np++;
21 }
22 nc=0;
23 }
24}
Únicamente ponemos la palabra while en lugar de for, copiamos la condición que

‘condicionaba’ (sí, lo sé) el break y la pegamos dentro de los paréntesis del while pero de
manera contraria (de == a != o de < a >).
No se hacen proyectos finales

Bueno pues lo dejé muy claro en el título ¿no? pero lo repito, no se hacen proyectos finales.
Cuando cree este blog lo hice pensando en ayudar a todos los estudiantes de programación
en c++ que necesitan algún empujón para lograr hacer sus propios programas.
Tengo pruebas para decir que casi nunca me niego a hacer programas pequeños que me
piden por correo o por comentarios, pero cuando me llegan correos pidiendo que les haga un
programa que “lleve el control del inventario de un almacén registrando cada entrada y
salida de producto… pidiendo tipo, cantidad, numero de control, precio… imprimiendo al
final del día el reporte….. y que además haga los cálculos para…. en formato de… y con 7
menús con… con un apartado de ayuda…. para mañana por favor” pues ni les respondo.
La verdad es que no se vale. Durante todo el año estuvieron haciendo programas sencillos
con los que era totalmente válido pedir ayuda, pero no, piden ayuda hasta el final del
semestre cuando les encargan un proyecto final.
Recuerden que yo también soy un estudiante y en estos días también estuve ocupadísimo con
tareas y trabajos. Por eso no había publicado nada. ¡Pero ya estoy de vacaciones!, así que ya
voy a tener un poco más de tiempo para atender mis blogs :)
Clasificar números en C++

Por medio de un comentario Gaby me pidió un programa que:
“Genere 10 números aleatorios del 0 al 50 y los clasifique en 2 rangos: menores que 10 y

mayores que 10 pero menores que 20.”
A nosotros nos sirve para practicar el uso de números random, de matrices y de ciclos.
El programa es este:
1#include<stdlib.h>
2#include<ctime>
3#include<iostream>
5int main()
6{
7 int numrnd[10], cls1[10]={0}, cls2[10]={0}, ct1=0, ct2=0;
9 cout << "Los numeros: ";
10 for(int i=0; i<=9; i++)
11 {
12 numrnd[i] = rand() % 51;
13 cout << numrnd[i] << ", ";
14 if(numrnd[i] < 10)
15 {
16 cls1[ct1] = numrnd[i];
17 ct1++;
18 }
19 if(numrnd[i] > 10 && numrnd[i] < 20)
20 {
21 cls2[ct2] = numrnd[i];
22 ct2++;
23 }
24 }
25 cout << endl << "Menores que 10: ";
26 for(int i=0; i<ct1; i++)
27 cout << cls1[i] << ", ";
28 cout << endl << "Mayores que 10 y menores que 20: ";
29 for(int i=0; i<ct2; i++)
30 cout << cls2[i] << ", ";
31}
 Para dudas respecto a la generación de números random está este post: Obtener
números aleatorios en C++.
 Para dudas respecto a la declaración y uso de matrices está este otro post: ¡Ah
nunca he escrito sobre matrices!, voy a tener que ponerme a ello.
 Para dudas con respecto a los ciclos for, sí tengo un post: Ciclos for en C++.
Tenemos 3 matrices, en la primera guardamos nuestros 10 números aleatorios, en la segunda

los números que queden en la primera clasificación (menores que 10) y en la tercera los que
queden en la segunda clasificación. Así que lo que hacemos es ir traspasando los valores de
la primera matriz a las otras dos según su valor. Para esto tenemos que llevar en el mismo
ciclo 3 cuentas diferentes, una para cada matriz.
Las variable ct1 y ct2 se encargan de ir cambiando los índices de las matrices cls1 y cls2
respectivamente, por lo que sólo deben aumentar cuando en realidad sea necesario.
Después lo único necesario es mostrar nuestras dos matrices. Como cada matriz puede tener
un número de elementos diferentes cada vez, tenemos que hacer dos ciclos, uno para cada
matriz con ct1 o ct2 como límite.
Como última aclaración sólo digo que, tal como dice el problema, el número 10 nunca va a
quedar clasificado en algún rango porque el 10 no es menor que 1o y tampoco es mayor que
10.
Convertir segundos a horas, minutos y segundos

Como les prometí en el post anterior, en este post vamos a hablar sobre un programa que
usa los operadores compuestos de manera muy útil: convierte los segundos en horas
minutos y segundos.
El programa es este:
#include <iostream>
using namespace std;
int main()
{
int sec, hr, min;
cout << "Introduce los segundos: "; cin >> sec;
cout << sec << " segundos son ";
hr = sec / (60*60);
sec %= 60*60;
min = sec / 60;
sec %= 60;
cout << hr << " horas " << min << " minutos y " << sec << " segundos" <<
endl;
}
Primero dividimos los segundos sec entre 60*60 (3600) para obtener los horas y lo guardamos
en hr. Noten que la variable sec no cambia.
Luego obtenemos el residuo de dividir sec / 60*60 (es lo que el operador % hace) y lo
guardamos en la misma variable. En este paso sí modificamos la variable sec, ahora contiene
los segundos iniciales menos las horas que ya obtuvimos en el paso anterior.
Ahora dividimos nuevamente la variable sec / 60 para obtener los minutos y lo guardamos en
hr. La variable sec no cambia.
Luego obtenemos el residuo de dividir sec / 60 (es lo que el operador % hace) y lo guardamos
en la misma variable. En este paso sí modificamos la variable sec, ahora contiene los
segundos iniciales menos las horas menos los minutos.
Ya sólo mostramos las tres variable y listo.
Ahora, si somos de los que nos preocupamos por el lenguaje, veremos que a veces hay
errores de ortografía como “1 minutos”. Para solucionar eso sólo necesitamos unos cuantos
ifs:
#include <iostream>
int main()
{
int sec, hr, min;
cout << "Introduce los segundos: "; cin >> sec;
cout << sec << " segundos son ";
hr = sec / (60*60);
sec %= 60*60;
min = sec / 60;
sec %= 60;
cout << hr << " hora";
if(hr != 1) cout << "s";
cout << " " << min << " minuto";
if(min != 1) cout << "s";
cout << " y " << sec << " segundo";
if(sec != 1) cout << "s";
}
Operadores compuestos en C++

Los operadores (en cualquier lenguaje de programación) son los símbolos que permiten
hacerle una operación a una o más variables. Los más conocidos son los operadores
aritméticos:
 + Suma
 - Resta
 * Multiplicación
 / División
 % Módulo (residuo de la división)
Otros son los lógicos (&&, ||), los relacionales (<, >, !=, ==), etc. Pero en este post, como
dice el título, vamos a ver los operadores compuestos en c++.
¿Cómo haríamos para sumarle a una variable int, por ejemplo, 3 unidades? Alguien que nunca
hubiera programado escribiría algo así:
mivar + 3;
Sabemos que eso no es válido porque una suma retorna un valor (el resultado) y ese valor
tiene que ser almacenado en una variable. En el código anterior ese valor no se almacena en
ninguna variable, por lo tanto ERROR. Sabiendo esto último podemos escribir esto:
mivar = mivar + 3;
En la variable mivar, guardamos el contenido de esa misma variable más tres. Todo bien ¿no?
eso es perfectamente válido y normal, sin embargo los operadores compuestos nos permiten
hacer lo mismo con menos código:
mivar += 3;
Como ven está inspirado en hacer que ‘lo-primero-que-se-nos-ocurre’ sea posible.
Así tenemos que:
mivar = mivar + 3; es lo mismo que mivar += 3;

mivar = mivar - 3; es lo mismo que mivar -= 3;
mivar = mivar * 3; es lo mismo que mivar *= 3;
mivar = mivar / 3; es lo mismo que mivar /= 3;
Bueno, para ver un poco de la utilidad de estos operadores y haciéndole un favor a un tal
Víctor, vamos a ver un programa que imprima los múltiplos de un cierto número (introducido
por el usuario) que haya desde 1 hasta otro cierto número (introducido por el usuario):
#include<iostream>
int main()
{
int num, lims, m=0;
cout << "Numero?: "; cin >> num;
cout << "Limite superior?: "; cin >> lims;
while(lims >= (m+=num))
{
cout << m << ", ";
}
}
Primero pedimos el número del cual queremos obtener múltiplos (num), luego el límite
superior (lims). m obtendrá el valor de los múltiplos y lo tenemos que igualar a 0 al inicio.
Luego tenemos un ciclo while. En español dice: “Me mantendré ejecutando mientras el lims
sea mayor o igual a m más num“. Dentro del ciclo mostramos la variable m.
Si, por ejemplo, num = 3, entonces la instrucción n+=num se desarrolla así:

m = 0;
m+=num; -----> m= m + num; -----> m = 0 + 3; -----> m = 3;
m+=num; -----> m= m + num; -----> m = 3 + 3; -----> m = 6;
m+=num; -----> m= m + num; -----> m = 6 + 3; -----> m = 9;
etc, etc.
Aquí podría poner un otro programa aún más útil para usar los operadores compuestos, pero
mejor lo dejo para el siguiente post. Ah y si tú eres Víctor, entonces tal vez te interese este
post: Cómo contar el número de veces que sucede algo.
Tipos de funciones en C++

Los tipos de funciones en c++ son 4, aunque en realidad son las combinaciones de las 2
cosas que una función puede hacer. Si andan perdidos en cuanto a funciones les recomiendo
leer mi post anterior: Funciones en C++.
Una función, como les decía, puede hacer (o no) dos cosas: 1 – Recibir datos y 2 – Retornar
datos. De esto surgen los cuatro tipos de funciones:
1. No reciben ni retornan
2. Reciben y no retornan
3. No reciben y retornan
4. Reciben y retornan
Vamos a hacer un programa que sume dos números, usando los cuatro tipos de funciones:
No reciben ni retornan
Las más sencillas. Para usarlas sólo tenemos que saber cómo crearlas y cómo llamarlas. Una
función se crea de esta forma general:
tipo nombre(){}
El ‘tipo’ se refiere al tipo de dato (int, float, void, char) y en las funciones que no retornan
siempre es void.
El ‘nombre’ es el nombre de la función: cualquiera que empiece con una letra, que sea
significativo y que no sea una palabra reservada.
Para llamarlas sólo hay que escribir el nombre de la función seguido de sus paréntesis y un
punto y coma (;).
nombre();
Así nuestro programa sería:

#include<iostream>
void sumar()
{
int num1, num2, r;
cout << "Numero 1: "; cin >> num1;
r = num1 + num2;
cout << "La suma es " << r;
}
int main()
{
sumar();
}
Como ven, todo lo que habríamos puesto en nuestro main mejor los pusimos en una función y
desde el main la llamamos. Una función siempre, siempre, siempre tiene que ir antes del
main.
Una función de este tipo que hemos usado muchas veces es getch();
Reciben y No Retornan
¿Cómo haríamos para pedir los dos números en el main y que la función haga la suma? Para
eso tenemos que hacer una función capaz de recibir datos, entonces la sintaxis cambia un
poco:
tipo nombre(tipo_var1 nombre_var1, tipo_var2 nombre_var2){}
‘tipo’ y ‘nombre’ se refieren a lo mismo y como no retorna el tipo siempre es void.
Dentro del paréntesis tenemos otros aspectos:
‘tipo_var1′ se refiere al tipo de la variable que nuestra función va a recibir.
‘nombre_var1′ se refiere al nombre de esa variable.
Si queremos recibir una variable hasta ahí es suficiente, si queremos otra variable ponemos
una coma (,) y declaramos la siguiente variable.
Para llamar la función hay que poner las variables que vamos a enviar dentro del paréntesis
en el mismo orden en que las declaramos en la función:
nombre(var1, var2);
Nuestro programa quedaría así:

#include<iostream>
void sumar(int num1, int num2)

{
int r;
r = num1 + num2;
}
int main()
{
int num1, num2;
sumar(num1, num2);
}
Pedimos los dos números en el main, los enviamos a la función, ésta los suma y los muestra.
Una función de este tipo que hemos usado muchas veces es el odiado por muchos, amados
por otros, gotoxy(x,y);
Retornan y No Reciben
¿Y si ahora queremos lo contrario? Pedir los números en la función, pero mostrar el resultado
en el main. Para eso necesitamos una función que retorne.
Recibir es enviar datos del main a la función. Retornar es enviar datos de la función al main.
Para retornar datos hay que hacer dos cosas: no usar void como tipo y usar return.
De forma general:
tipo nombre() { return var; }
El ‘tipo’ tiene que ser del tipo de variable que queremos retornar, si nuestra variable
retorna una variable int, pues el tipo de la función es int.
Para indicar qué variable estamos retornando usaremos la palabra return seguido de la
variable. Usualmente esto va al final de la función.
Para llamar a la función hay que preparar un colchón en donde caiga la variable que está
retornando.
var = nombre();
La variable que está retornando nuestra función se va a almacenar en la variable ‘var’. Este
es un buen momento para recordarles que las variables declaradas entre dos llaves {}
únicamente existen entre esas dos llaves. O sea que la variable ‘var’ de la función no es la
misma que la variable ‘var’ de la función; sin embargo la var del main está adquiriendo el
valor de la var del main. Un poco confuso lo sé, no se preocupen.

#include<iostream>
int sumar()
{
int num1, num2, r;
r = num1 + num2;
return r;
}
int main()
{
int r;
r = sumar();
}
¿A alguien se le ocurre una función conocida de este tipo?
Reciben y Retornan
Ahora queremos que nuestra función únicamente sume, el main se va a encargar de pedir los
números y sumar los resultados. Para eso necesitamos que nuestra función reciba las
variables y además retorne el resultado. ¡Wow! ¿Es acaso eso posible? Claro que sí.
Es sólo cuestión de combinar las funciones que reciben y no retornan con las que retornan y
no reciben.

#include<iostream>
int sumar(int num1, int num2)

{
int r;
r = num1 + num2;
return r;
}
int main()
{
int num1, num2, r;
r = sumar(num1, num2);
}
Las funciones de la librería math.h son en su mayoría de este tipo. sqrt(); pow(); sin();
En principio puede parecer que las funciones sirven únicamente para organizar el código, lo
cual es cierto, pero no sólo eso. ¿Se imaginan si tuviéramos que escribir todo el código detrás
de un simple gotoxy();? Ah verdad…
Bueno, no me iba a quedar tranquilo si no les mostraba la versión optimizada de la última

función:
#include<iostream>
int sumar(int num1, int num2)

{
return num1 + num2;
}
int main()
{
int num1, num2;
cout << "La suma es " << sumar(num1, num2);
}
:D
Funciones en C++
Supongo que ya es hora de retomar el blog y ponerme a hablar de funciones en c++. Una
función es un pedazo de código fuera del main, con un nombre y que puede ser ‘llamado’
desde otra parte de nuestro programa.
Imagínense que están entrenando a su perro a hacerse el muertito. Cada vez que ustedes
dicen ‘muertito‘, el perro se tira de espaldas en el suelo, cierra los ojos y saca la lengua. En
programación, el contenido de la función sería tirarse de espaldas, cerrar los ojos y sacar la
lengua; el nombre de la función sería muertito; y cada vez que nosotros decimos muertito
estamos llamando a la función.
Nuestra función sería algo así:

void muertito()
{
Perro.Tirarse(posicion='espalda');
Perro[OjoDer].Cerrar();
Perro[OjoIzq].Cerrar();
Perro[Lengua].Sacar();
}
Jajaja, bueno, bueno. Ya en serio vamos a hacer un clásico Hola Mundo pero usando una
función:
#include<iostream>
void hola()
{
cout << "Hola Mundo!";
}
int main()
{
hola();
}
Como ven, esta función es muy estúpida. No nos beneficia en nada y nos hace escribir más
código del necesario, pero nos sirve para ver cómo actúa una función: al momento de llamar
a la función, el compilador se brinca a la función, la ejecuta y cuando termina, vuelve al
punto desde donde brincó.
Si pudieran leerle la mente a un compilador, este diría:
Linea 1. Incluir la librería iostream. OK
Linea 2. Usar el namespace estándar. OK
Linea 3. Oh! una función llamada hola, la recordaré.
Linea 4. Llave. Parte de la función. Ignorar
Linea 5. Imprimir “Hola Mundo!”. Parte de la función. Ignorar
Linea 6. Llave. Parte de la función. Ignorar
Linea 7. ¡Por fin el main!
Linea 8. Llave. Entrar
Linea 9. Esta función se me hace conocida… oh sí ya recuerdo. Ejecutar líneas 4, 5 y 6
Linea 10. Llave. Salir
Ahora veamos una función que sí nos es útil:

#include<iostream>
void hola(char nombre[50])

{
cout << "Hola " << nombre << "!";
}
int main()
{
char nombre[50];
cout << "Cual es tu nombre?: "; cin.getline(nombre, 50, '\n');
hola(nombre);
}
Primero pedimos un nombre, lo guardamos en una variable y se le mandamos a la función

para que lo muestre.
No se preocupen, si nunca habían visto una función tal vez no entiendan la sintaxis, pero el
objetivo de este post es que sepan qué es una función y para qué se puede usar. En el
siguiente post voy a explicar la sintaxis de los cuatro tipos de funciones en c++.
Cómo pasar una matriz o arreglo como parámetro a

una función
Bueno, casi creo que nunca he hablado de matrices, parámetros o funciones en este blog,
pero este post es una petición de Rodrigo que me dijo por email que tenía problemas con su
tarea porque no sabe cómo pasar una matriz como parámetro a una función en c++. Es
algo sencillo, pero difícil de deducir. Veamos.
Si tu arreglo es de una dimensión…
int matriz[4];
… la forma de declarar la función es la siguiente:
void fx(int m[4]) { ...código... }
Y la forma de llamar la función sería:
fx(matriz);
Si el arreglo es de dos dimensiones…
int matriz[4][3];
… pues es lo mismo:
void fx(int m[4][3]) { ...código... }
fx(matriz);
Si la función retorna una matriz…
int matriz[4];
… se declara normal:
void fx(int m[4]) { return matriz[4]; }

matriz[4] = fx(matriz);
Este programa pide tres números, los almacena en una matriz, le suma 1 a cada elemento y
los muestra, usando para cada acción una función. Así que tenemos funciones que reciben
matrices y que retornan matrices. Chéquenlo.
#include<iostream>
void pedir(int matriz[3], int len)

{
for(int i=0; i<=len; i++)
{
cout << "Numero " << i+1 << ":? ";
cin >> matriz[i];
}
}
int sumar(int matriz[3], int len)

{
matriz[i]++;
return matriz[3];
}
void mostrar(int matriz[3], int len)

{
cout << matriz[i] << " ";
}
int main()
{
int matriz[3]={0}, len = sizeof(matriz)/sizeof(int);
pedir(matriz, len-1);
matriz[3] = sumar(matriz, len-1);
mostrar(matriz, len-1);
return 0;
}
Gráfica de Seno y Coseno en C++

Juand a través de un comentario me pidió ayuda con un programa que grafique utilizando
gotoxy las gráficas de seno y coseno en c++. El programa me pareció interesante y, aunque
tuve que desempolvar el Borland C++ que usaba en la prepa, lo hice… feo, pero lo hice.
A mi parecer, para graficar por ejemplo la función seno, hacen falta 3 pasos:
1. Hacer un ciclo de 0 a 360º (con aumentos de 5 queda muy bien) con for, algo muy normal.
2. Calcular, obviamente, el seno de cada valor. Para esto la librería math.h nos regala la
función sin(). Su uso es el obvio, pero el asunto es que todas las funciones trigonométricas
que usa c++ trabajan en radianes. Es decir que primero tendremos que convertir nuestro
ángulo en radianes y luego ya sacar el seno. Si la variable ‘i’ contiene el ángulo y tenemos ya
definida la constante PI, la función quedaría así:
sin(i/180*PI)
3. Luego viene la parte más rara, convertir ese valor en un entero que pueda meter
como coordenada en un gotoxy. Si tenemos una variable int y y la igualamos a
nuestra función anterior podría quedar bien si multiplicamos por 10:
int x, y; y = sin(i/180*PI)*10; gotoxy(x,y);
Nos quedaría nuestra gráfica en una escala 1:10, pero al correr el programa veremos que
hay muchos valores de seno que son 10 (por el redondeo) y por lo tanto la gráfica se ve
achatada.
Para mejorar un poco eso (de todos modos queda un poco fea) podemos usar la función ceil()
incluida también en la librería math.h que nos redondea los decimales. Y esta vez
multiplicamos por 20, redondeamos, dividimos entre 2 y convertimos a int. Nos vuelve a
quedar escala 1:10 (¿o 10:1 …? no se) pero ya no hay tantas cantidades amontonadas en el 10
y -10.
El programa ya listo para graficar seno está aquí abajo, obviamente para graficar coseno sólo
hay que cambiar la función sin por cos, y copiar, pegar y hacer un menú no debe ser difícil.
#include<stdio.h>
#include<conio.h>
#include<math.h>
#define PI 3.14159265
int main()
{
int x=2, y;
for(float i=0; i<=360; i+=5)
{
y = ceil(sin(i/180*PI)*20)/2;
gotoxy(x, 12-y);printf("o");
x++;
}
getch();
return 0;
}
Calcular ángulos de un triángulo en C++
En el post anterior vimos cómo saber si un triángulo es rectángulo, acutángulo u
obtusángulo en C++, y les anticipé que haría una nueva versión del mismo programa pero
que nos calculara además los ángulos del triángulo.
El programa es este.
#include<math.h>
#include<iostream>
#define PI 3.14159265 // nuNcA cAmbieZz we!!

int main()
{
float a, b, c, A, B, C;
cout << "Introduce lado a: "; cin >> a;
cout << "Introduce lado b: "; cin >> b;
cout << "Introduce lado c: "; cin >> c;
A = acos((b*b+c*c-a*a)/(2*b*c))*180/PI;
B = acos((a*a+c*c-b*b)/(2*a*c))*180/PI;
C = acos((a*a+b*b-c*c)/(2*a*b))*180/PI;
if(A == 90 || B == 90 || C == 90)
cout << "El triangulo es rectangulo. ";
if(A < 90 && B < 90 && C < 90)
cout << "El triangulo es acutangulo. ";
if(A > 90 || B > 90 || C > 90)
cout << "El triangulo es obtusangulo. ";
cout << "\nY sus angulos son: A:" << A << " , B:" << B << " y C:" << C;
}
Para calcular los ángulos utilizamos la ley de cosenos, de hecho en el anterior también lo
utilizamos pero no completamente (la ley de cosenos es una ‘ampliación’ del teorema de
pitágoras). La ley de cosenos la vemos comúnmente como:
a2 = b2 + c2 -2(b*c)*cos(A)
Si la despejamos en cos(A), nos queda:
cos(A) = (b2 + c2 - a2) / 2(b*c)
Si despejamos A (o sea el ángulo), obtenemos:
A = arccos(b2 + c2 - a2 / 2(b*c))
Que es lo que utilizamos calcular los ángulos, lamentablemente la función que nos da C++ en
su librería math.h, acos() nos devuelve el resultado en radianes. Para convertirlo a grados
solo tenemos que multiplicar el resultado por 180/PI. Ahora que ya tenemos los tres ángulos
de nuestro triángulo, es facilísimo saber cuándo es cada tipo de triángulo.
La función acos() está en la librería math.h y sirve para encontrar el arco coseno. En esta
librería hay muchas funciones muy útiles: math.h
Otro detalle sencillo pero que no habíamos visto es el asunto de PI. Al principio del programa
nos encontramos con:
#define PI 3.14159265
Esto significa que estamos declarando una constante con el nombre PI y con un valor de
3.14159265. Una constante, como su nombre lo indica, nunca cambia a lo largo del
programa.
Bueno, pues fue un programa bastante entretenido, me gustó hacerlo :)
Saber si un triángulo es rectángulo, acutángulo u

obtusángulo en C++
Emanuel por medio de un comentario me pidió ayuda para hacer un programa en c++ que
nos dijera si un triángulo es rectángulo, acutángulo u obtusángulo pidiendo solamente los
lados. El programa me pareció interesante de hacer y pues lo hice :)
El programa resulta bastante sencillo, pero para deducir cómo hacerlo está un poco
complicado. Veamos la siguiente imagen:
El triángulo 1 es un clásico triángulo rectángulo. Si aumentáramos el lado c de 5 a 6
obviamente el ángulo aumentaría y por lo tanto sería un triángulo obtusángulo (2). Si por el
contrario, disminuyéramos el lado de c 5 a 4, el ángulo disminuiría y por lo tanto sería un
triángulo acutángulo (3).
Sabiendo esto veamos cómo se comporta Pitágoras en cada caso (o sea no él, su teorema):
Si despejamos su famoso teorema obtenemos que a2 + b2 – c2 = 0.
Veamos como se comporta este teorema en nuestro triángulo 1:
32 + 42 - 52 = 0
¡Listo!, ya sabemos que el triángulo es rectángulo, porque el teorema de Pitágoras sólo sirve
para triángulos rectángulos.
Ahora con el triángulo 2 (obtusángulo):
32 + 42 - 62 = -11
¡Un número negativo! Con los triángulos obtusángulos el teorema de Pitágoras da números
negativos.
Y por último el triángulo 3 (acutángulo):
32 + 42 - 42 = 9
¡Un número positivo! Con los triángulos acutángulos el teorema de Pitágoras da números
positivos.
Ahora que ya sabemos cómo identificar cada triángulo nos surge otro problema: El usuario
sólo va a introducir tres lados cualquiera, ¿cómo saber cual es a, cual es b y cual es c? Pues
no hay forma de saberlo, hay que hacer cada paso tres veces tomando el teorema como a 2 +
b2 – c2, luego a2 + c2 – b2 y al final b2 + c2 – a2.
Ahora si, veamos el programa:

#include<iostream>
int main()
{
int a, b, c, A, B, C;
cout << "Introduce lado 1: "; cin >> a;
cout << "Introduce lado 2: "; cin >> b;
cout << "Introduce lado 3: "; cin >> c;
A = (b*b+c*c-a*a);
B = (a*a+c*c-b*b);
C = (a*a+b*b-c*c);
if(A == 0 || B == 0 || C == 0)
cout << "El triangulo es rectangulo. ";
if(A > 0 && B > 0 && C > 0)
cout << "El triangulo es acutangulo. ";
if(A < 0 || B < 0 || C < 0)
cout << "El triangulo es obtusangulo. ";
La única parte no explicada es la de las condiciones. Si en cualquiera de los tres formas de

tomar el teorema nos resulta 0 es rectángulo, por lo tanto se usa ||. Para ser acutángulo, las
tres formas del teorema deben ser mayores a 0, se usa &&. Con una sola forma del teorema
que resulte menor a 0 es obtusángulo, se usa ||. Para mayor información de esos operadores
leer esto: Operadores lógicos es C++.
¿Cómo ven el programita? Está sencillo ¿no? Tal vez después haga una modificación para que
además te calcule los ángulos del triángulo.
Cómo contar el número de veces que sucede algo

Bueno, en esta ocasión vamos a ayudarle a un comentarista de este blog con sus problemas,
el me ha pedido un programa que cuente la cantidad de números primos que hay en un
rango, no se ha conformado con saber si un número es primo o no o con saber cómo
mostrar los números primos en un rango, así que le vamos a ayudar con la única parte de
su programa que le falta: saber cómo contar el número de veces que sucede algo.
Para esto vamos a usar una variable tipo int (entero) que va a ir aumentando una unidad
cada vez que ocurra ese ‘algo’ que queremos contar. Veamos como funcionaría un contador
dentro de un ciclo:
#include<iostream>
int main()
{
int contador=0;
for(int i=0; i<10; i++)
contador++;
cout << contador;
}
Obviamente esto muestra un 10 en pantalla. Porque la variable ‘contador’ aumenta una
unidad cada vez que el ciclo da una vuelta.
contador++; es lo mismo que contador = contador + 1;
Ahora veamos como funciona si agregamos una condición:

#include<iostream>
int main()
{
int contador=0;
for(int i=0; i<10; i++)
{
if(i==5)
contador++;
}
cout << contador;
}
Esto obviamente muestra en pantalla un 1, porque solo una vez i vale 5. Ahora con una
condición más complicada:
#include<iostream>
int main()
{
int contador=0;
for(int i=0; i<10; i++)
{
if(i%2==0)
contador++;
}
cout << contador;
}
Con el operador % se obtiene el residuo de la división de los dos números entre los que está.
Si la condición es que i/2 tenga residuo un de 0, significa que estamos dejando pasar sólo los
números pares, por lo que deberá mostrarse en pantalla un 5.
Qué fácil no?, ahora nuestro amigo ya tiene todo lo necesario para armar su programa.
Función delay() en C++

Una función a veces útil a veces no mucho es el delay(), sirve para hacer una pausa de ‘n’
segundos. En algunos compiladores Borland esta función se incluye en la librería conio.h pero
como aquí estamos del lado del software libre vamos a hacer nosotros mismos esta función.
Primero veamos cómo se usa:
delay(variable_tipo_int);
es decir:
int secs=10;
delay(secs);
delay(numero_entero);
es decir:
delay(12);
Y claro, la función es esta:
void delay(int secs) {

for(int i = (time(NULL) + secs); time(NULL) != i; time(NULL));
}
1. La función time(NULL) nos devuelve el segundo exacto en que estamos.

2. Si le sumamos cierta cantidad de segundos obtenemos una fecha en el futuro.
3. En cada vuelta del ciclo se checa si esa fecha en el futuro es diferente a la fecha
actual.
4. En cuanto las dos fechas son iguales el ciclo acaba y el programa continúa.
Veamos como se usa en un programa en c++:

#include<time.h>
#include<iostream>
void delay(int secs) {

for(int i = (time(NULL) + secs); time(NULL) != i; time(NULL));
}
int main()
{
int sec;
cout << "Segundos a pausar?: "; cin >> sec;
delay(sec);
}
Para poder usar la función delay de esta forma es necesario ponerla en todos los programas
en donde necesitemos usarla (ahora me doy cuenta que no he escrito mucho sobre
funciones) e incluir siempre la librería #include<time.h> o #include<ctime>.
Generar un string aleatorio en C++

No sé, es algo que se me ocurrió y que es muy fácil de hacer. Lo único que tenemos que
hacer es ver a un string no como una frase, sino como un conjunto de caracteres; y además
ver a los caracteres no como letras, sino números del código ASCII.
Teniendo esto claro, es muy fácil generar un números aleatorios (que representas letras)
para llenar cada elemento del arreglo que es nuestro string. Veamos:
#include<stdlib.h>
#include<time.h>
#include<iostream>
int main()
{
char strrnd[10];
srand(time(NULL));
for(int i=0; i <= 9; i++)
strrnd[i] = 33 + rand() % (126 - 33);
cout << strrnd;
cin.get();
}
1. Primero declaramos un string de nombre strrnd.

2. Luego inicializamos nuestro random.
3. Con un ciclo recorremos cada elemento del string.
4. Y cada elemento lo llenamos con un número aleatorio entre 33 y 126, que en el
código ASCII representan todos las símbolos letras y números normales.
5. Y listo, ya hemos creado un string aleatorio en c++.
Si tienen duda con los números aleatorios pueden checar este post: Obtener número
aleatorios en c++. Aquí pueden ver el código ASCII.
Si quieren que muestre, por ejemplo, solo letras minúsculas, tendrían que modificar la
fórmula del random para que generara números entre el 97 y 122.
Cada tres días

No creo que nadie se haya fijado, pero desde el regreso de este blog, las entradas han
estado apareciendo cada tres días. Y este post es para hacérselos notar.
¿Porqué tres días? Bueno pues porque en los blogs de este tipo es muy bueno tener
regularidad con respecto a la frecuencia de los posts; comprometerme a publicar todos los
días sería demasiado, dos días estaría bien, pero tres días me queda mucho más adecuado.
Así que ya saben, si no quieren desperdiciar tiempo, sólo chequen el blog cada tres días o
suscríbanse por mail o por feed (allá en la sidebar están los links, soy un flojo).
Como usar cin.getline en C++

Bueno, siguiendo con la línea de los posts sobre la librería string.h les traigo esta función
que no está en esa librería pero que es muy útil al trabajar con strings. Ya dijimos que
un/una string es una variable que puede contener 0, uno o más caracteres.
Ya vimos en nuestra introducción a string.h cómo declarar un string, hacerle algunas

modificaciones y cómo mostrarlo. Ahora veremos como pedir un string (que el usuario la
introduzca por medio del teclado).
Esto es muy sencillo si usamos la función cin.getline(); Esta función necesita tres datos o
parámetros:
1. Nombre. El nombre de la variable que va a contener el string

2. Longitud. La cantidad de caracteres que queremos que se puedan introducir
(nunca mayor que la longitud del string).
3. Caracter de fin. El caracter que el usuario va usar como final de la cadena. Por
lo general es el ‘enter‘ que se representa como ‘\n’ (diagonal n).
Por ejemplo, supongamos que tenemos un arreglo char de 500 elementos llamado str
(nuestra string) y queremos pedirle al usuario que la “llene”, la función cin.getline quedaría
así:
cin.getline(str, 500, '\n');
Como ven, los parámetros van separados por comas (,), y el caracter de fin está entre
comillas simples (‘). Pero bueno, dejemos de suponer y empecemos a programar.
#include<iostream>
int main()
{
char str[500];
cout << "Introduce una frase: ";
cin.getline(str, 500, '\n');
cout << "Tu frase es: " << str;
cin.get();
}
Mas sencillo no podría ser.
Triángulo de Pascal en C++

¿Han escuchado eso de que en el triángulo de pascal cada número es la suma de los dos que
están sobre él? ¡PUES LES HAN MENTIDO!, eso no es más que una coincidencia y la forma mas
fácil de escribirlo en el pizarrón. En realidad el triángulo de pascal es una matriz donde cada
elemento es el coeficiente binomial o combinación de sus coordenadas. Las pruebas.
El caso es que para obtener el triángulo de pascal en c++ hay muchas formas, pero la que
está a continuación yo la considero especial porque está basada en su propia definición.
#include<iostream>
int factorial(int n)
{
if(n<2)
return 1;
else
return n * factorial(n-1);
}
int combinacion(int n, int r)

{
if(r==1)
return n;
else
{
if(n==r)
return 1;
else
return factorial(n) / (factorial(r) * factorial(n - r));
}
}
int main()
{
for(int i=0; i<=6; i++)
{
for(int ii=0; ii<=i; ii++)
cout << combinacion(i, ii) << " ";
cout << endl;
}
return 0;
}
Vamos analizándolo:
1. La primera función es para obtener el factorial de forma recursiva.
2. La segunda es para obtener el coeficiente binomial o combinación de dos números, es en

esencia esta fórmula:
C(n,r) = n! / r!(n-r)!
Mas información sobre coeficientes binomiales.

3. En el main hay dos ciclos que se encargan de armar una matriz para obtener el
coeficiente binomial de cada uno de ellos.
 La primera pareja de numeros es (0,0) y su combinación es 1. Nuestro primer

numero del triangulo de pascal.
 La siguiente es (1,0) y luego (1,1) cuyas combinaciones son 1 y 1. Segunda línea.
 Luego tenemos (2,0) (2,1) y (2,2) cuyas combinaciones son 1, 2 y 1. Tercera
linea
 Y así seguimos obteniendo nuestras líneas.
Y pues así es, el que me diga que no tiene forma de triángulo está ciego, porque si es
triángulo, lo que pasa es que no es isósceles.
Primo o no ¡SIN CICLOS! en C++

Me preguntaban en los comentarios de este post: Primo o no, que si habría alguna forma de
hacer ese mismo programa pero sin ciclos. Mmmm…
Pues mi primera respuesta es no. Pero hay una forma muy burda de aproximarse a él. El
siguiente programa es para calcular si un número es primo o no sin ciclos y es infalible
hasta el 168, a partir de ahí puede que le atine o puede que no.
#include<iostream>
int main()
{
int n;
cout << "Introduce un numero: "; cin >> n;
if(n!=2 & n%2==0)
cout << "No es primo";
else
{
if(n!=3 & n%3==0)
else
{
if(n!=5 & n%5==0)
else
{
if(n!=7 & n%7==0)
else
{
if(n!=11 & n%11==0)
else
{
cout << "Es primo";
}
}
}
}
}
}
 Como vemos, primeramente checa si n es igual a 2; si no, checa si el residuo de

n/2 es cero. Si si, no es primo; si no, sigue.
 Luego checa si n es igual a 3; si no, checa si el residuo de n/3 es cero. Si si, no
es primo; si no, sigue.
 Lo mismo con el 5, el 7 y el 11.
Con eso obtenemos un buen número de números en los que estamos seguros que no
fallaremos. Si agregamos el 13, agrandamos esa cantidad; y aún mas con el 17, el 19, …
como en esta versión optimizada, que tiene su primer error con el 1681 (que no es primo)
#include<iostream>
int main()
{
int n;
cout << "Introduce un numero: "; cin >> n;
if((n!=2 & n%2==0)||(n!=3 & n%3==0)||(n!=5 & n%5==0)||(n!=7 & n%7==0)||
(n!=11 & n%11==0)||(n!=13 & n%13==0)||(n!=17 & n%17==0)||(n!=19 & n
%19==0)||
(n!=23 & n%23==0)||(n!=29 & n%29==0)||(n!=31 & n%31==0)||(n!=37 & n
%37==0))
else
cout << "Es primo";
}
Pero pues de eso no se trata, los ciclos son para evitar las cantidades interminables de ifs,
así que usémoslos.
Ah y recuerden que si corren un programa y su compilador no se pausa solo, tienen que

agregar cin.get();cin.get(); al final del programa, antes de la llave de cierre del main.
Si llegaste aquí buscando un programa para saber si un número es primo o no, sigue el link
que está al principio del post.
Introducción a string.h
string.h es una librería de c++ que contiene funciones que nos facilitan la vida al trabajar
con cadenas o strings. Una cadena es un conjunto de caracteres almacenados en una
variable.
Deberíamos saber que char es un tipo de dato que almacena un caracter, por lo tanto un
arreglo lineal de caracteres es una cadena:
char str[100];
Ahora podemos llenar nuestra cadena..
str ="Soy una cadena";
…y mostrarla
cout << str;
Pero recuerden que no podemos hacer nada de esto si no tenemos incluida la librería
string.h. Vamos a ver un programa de ejemplo:
#include<string.h>
#include<iostream>
int main()
{
char esunacadena[100] = "Soy una cadena", esunacopia[100];
strcpy(esunacopia, esunacadena);
strcat(esunacopia, " - copia");
cout << esunacadena << endl << esunacopia;
cin.get();
return 0;
}
1. Primero declaramos dos cadenas (‘esunacadena’ y ‘esunacopia’) que pueden

tener hasta 100 caracteres, ‘esunacadena’ la llenamos con el texto “Soy una
cadena“.
2. Luego con la función strcpy copiamos el contenido de ‘esunacadena’ a
‘esunacopia’. Ahora las dos cadenas tienen el mismo texto.
3. Ahora con la función strcat agregamos el texto ” - copia” al final
de’esunacopia’.
4. Al final solo mostramos las dos cadenas.
Bastante fácil ¿no? En los próximos días voy a postear otros programas muy sencillos para
seguir checando las funciones mas comunes para trabajar con cadenas.
Centrar texto automáticamente sin gotoxy

Pues si, en este post vamos a hacer un programa en c++ que lee una frase y luego la
muestra centrada en la pantalla, todo eso ¡sin usar gotoxy! wow.
Bueno, usando gotoxy sería mas fácil, pero este blog promueve el no uso de la librería
conio.h (Cómo dejar de usar conio.h) así que lo vamos a hacer como les dije.
#include<iostream>
#include<string.h>
int main()
{
char str[100];
cout << "Una frase: "; cin.getline(str, 100, '\n');
int numofch = strlen(str);
for(int i=1; i<(40-(numofch/2)); i++)
cout << " ";
cout << str;
cin.get();
return 0;
}
A la consola le caben 80 caracteres a lo largo, su mitad son 40; enseguida tenemos que
averiguar el numero de caracteres que tiene la frase que se acaba de introducir y dividirlo
entre dos. Supongamos que la frase es “hola”:
1. ‘Hola’ tiene 4 caracteres.

2. La mitad de la consola es 40.
3. Si a los 40 le restamos la mitad de los caracteres de la frase, obtenemos el
punto en donde debe comenzar la frase para quedar centrada. 40 – (4/2) = 38
4. Ahora con un ciclo damos 38 espacios y luego imprimimos la frase.
Si quieren utilizar gotoxy, el proceso es el mismo hasta el último paso, donde guardarían el
valor obtenido en una variable y luego lo pondrían en el lugar adecuado de la función.
La función strlen está en la librería string.h y nos devuelve el número de caracteres que
tiene una cadena, viene de string length.
A propósito me he dado cuenta que no he hablado casi nada de la librería string.h, voy a ver
si hago unos cuantos posts sobre ella.
Declarar variable dentro de un ciclo for

En el programa anterior use la “técnica” de declarar una variable dentro de un ciclo for y
luego de publicarla me di cuenta de que algunas personas podrían encontrar eso algo
confuso.
Es casi exactamente lo mismo escribir esto:
int i=0;
for(i=0; i<=10; i++)
{
printf("%i", i);
}
…que esto:
for(int i=0; i<=10; i++)

{
printf("%i", i);
}
La única diferencia es que en el primero ‘i’ es una variable como cualquier otra y en el
segundo ‘i’ solo sirve dentro del ciclo for. Esto mas que ser una desventaja es una ventaja,
ya que te permite usar la misma variable en todos lo ciclos que quieras en el mismo
programa. Yo en lo personal siempre uso ‘i’ como la variable que controla cualquier ciclo, si
llegara a haber un ciclo dentro de otro, uso ‘ii’.
Factorial de forma sencilla en C++

Ya vimos como calcular el factorial de un número c++ en forma recursiva, sin embargo hay
una forma mucho mas fácil de entender y de aplicar (pero menos eficiente). Vamos viendo:
Si el factorial de un número es la multiplicación de cada número desde 1 hasta ese número

(por ejemplo factorial de 4 = 1*2*3*4 = 24), entonces es muy sencillo crear un ciclo de 1
hasta el número pedido en c++ para hacer el cálculo.
#include<iostream>
int main()
{
int num,fact=1;
cout << "::FACTORIAL::" << endl;
cout << "Introduce un numero: "; cin >> num;
for(int i=2; i<=num; i++)
{
fact = fact * i;
}
cout << "Su factorial es: " << fact;
return 0;
}
¿Entonces porqué el ciclo empieza en 2? Si comenzara en 1, el proceso para el número 3 (por

poner un ejemplo) sería así:
 fact = fact * i -> fact = 1 * 1 -> fact = 1

Como ven, el primer paso es totalmente innecesario.
Recursividad aplicada: Torres de Hanoi

Este juego matemático es clásico de los problemas de programación. Hoy vamos a ver cómo
calcular el número de movimientos necesarios para resolver el juego según el número de
discos, de forma recursiva en C++.
#include<stdio.h>
int hanoi(int n)
{
if(n==1)
return 1;
else
return 2 * hanoi(n-1) + 1;
}
int main()
{
int disc, mov;
printf("::TORRES DE HANOI::\n");
printf("Numero de discos: ");scanf("%i",&disc);
printf("\tMovimientos necesarios: %i\n", hanoi(disc));
return 0;
}
Otro algoritmo raro. Lo que sabemos es que si tenemos 1 disco el número de movimientos es
1 y que ese es nuestro caso base (si n==1 retorna 1), a partir de ahí el número de
movimientos se puede calcular si multiplicamos por dos el número de movimientos para n-1 y
le sumamos 1, o sea: 2 + hanoi(n-1) + 1
 Si son 2 discos, entonces 2 * hanoi(1) + 1 = 2 * 1 + 1 = 3

 Si son 3 discos, entonces 2 * hanoi(2) + 1 = 2 * 3 + 1 = 7
 etc
Recursividad aplicada: Máximo Común Divisor

Ooootro post sobre recursividad, pero no se preocupen ya solo queda este y otro. Esta vez
vamos a calcular el máximo común divisor de dos números de forma recursiva en c++.
#include<stdio.h>
int MCD(int x, int y)
{
if(y==0)
return x;
else
return MCD(y, x%y);
}
int main()
{
int num1=0,num2=0;
printf("::MAXIMO COMUN DIVISOR::\n");
printf("Introduce el primer numero: ");scanf("%i",&num1);
printf("Introduce el segundo numero: ");scanf("%i",&num2);
printf("\tEl resultado es: %i\n", MCD(num1, num2));
return 0;
}
Este es uno de esos algoritmos recursivos raros o, mejor dicho, difíciles de comprender, mi
cerebro estuvo un buen rato echando humo tratando de comprender la lógica con que lo
armaron y mi conclusión es que funciona de pura rana. Bueno, al final si supe como funciona
pero no porque.
Recursividad aplicada: Serie de Fibonacci
0, 1, 1, 2, 3, 5, 8, 13, 21, …, la serie de Fibonacci es bastante interesante e incluso aparece
en la naturaleza. Comienza con un 0, luego un 1 y a partir de ahí cada número es la suma de
los dos siguientes. Eso último nos indica recursividad. Veamos como mostrar n números de la
serie de Fibonacci de forma recursiva en C++.
#include<stdio.h>
int fibonacci(int n)
{
if (n<2)
return n;
else
return fibonacci(n-1) + fibonacci(n-2);
}
int main()
{
int num=0,res=0;
printf("::NUMEROS DE FIBONACCI::\n");
printf("Introduce el numero de numeros: ");scanf("%i",&num);
printf("\t");
for(int i=0;i<=num-1;i++)
{
res = fibonacci(i);
printf("%i ", res);
}
printf("\n");
return 0;
}
Es la primera vez que vemos un la llamada a la función dentro de un ciclo. Eso es porque la
función calcula el n-ésimo número de la serie, y para mostrarlos todos tenemos que hacer un
ciclo que repita la función tantas veces como sea necesario.
Recursividad aplicada: Convertir Decimal a Binario

Siguiendo con esto de la recursividad hoy les traigo un nuevo programín, Convertir Decimal
a Binario de forma recursiva.
#include<stdio.h>
void binario(int n)
{
if (n!=0)
{
binario(n/2);
printf("%i",n%2);
}
}
int main()
{
int num=0;
printf("::CONVERTIR DECIMAL A BINARIO::\n");
printf("Introduce un numero: ");scanf("%i",&num); //Pedir variable num
printf("\t");binario(num);printf("\n"); //Llamar la función
return 0;
}
Está basado en el método que usamos para convertir un número decimal a binario “a mano”:
dividir el número entre dos hasta que quede 0 y apuntar los residuos del último al primero.
Recursividad aplicada: Factorial

Hola de nuevo, ¿cuánto tiempo pasó? mmm no sé pero bueno… lo importante es que ya estoy
de vuelta y ahora sí me voy a dar el tiempo de actualizar este blog más seguido, pero basta
de cosas personales.
No me quiero meter en rollos de explicar lo que es la recursividad (googleen y diviértanse

leyendo), lo que quiero es mostrarles algunos ejemplos muy sencillos de dónde podemos
aplicar la recursividad. Hoy toca calcular el factorial de un numero de forma recursiva.
Es el código recursivo más fácil que se pueden encontrar:

#include<stdio.h>
int factorial(int n)
{
if(n<2)
return 1;
else
return n * factorial(n-1);
}
int main()
{
int num=0;
printf("::CALCULAR FACTORIAL::\n");
printf("Introduce un numero: ");scanf("%i",&num); //Pedir variable num
printf("\tEl resultado es: %i\n", factorial(num)); //Llama la funcion e imprime
resultado
return 0;
}
Explicación
El caso base es que cuando n valga 1 o 0 retorna un 1, de lo contrario retorna la
multiplicación de n * el factorial del numero anterior n-1. Supongamos que introducimos el
número 3, cuyo factorial es 6 (3*2*1 = 6).
1. n=3 No entra al caso base. Guardamos para después la operación 3 * factorial(2)

2. n=2 No entra al caso base. Guardamos para después la operación 2 * factorial(1)
3. n=1 Entra al caso base. Retorna 1, por lo tanto factorial(1) = 1
4. Hacemos la última operación que guardamos 2 * factorial(1) = 2 * 1 = 2, por lo
tanto factorial(2) = 2
5. Hacemos la siguiente operación que guardamos 3 * factorial(2) = 3 * 2 = 6
6. El factorial es 6
¡Uh que fácil!
Obtener numeros aleatorios en C++ (rand, srand)

Es algo muy frecuente, cuando ya dominas todo eso de pedir y almacenar datos, ahora tu
profesor te pedirá que tus programas generen números aleatorios para automatizar el
proceso de llenar arreglos y todo eso.
Así que lo primero que tenemos que hacer es incluir la librería:
#include<stdlib.h>
Luego inicializar los números aleatorios incluyendo esto:
srand(time(NULL));
*Actualización: No se porqué con algunos IDE’s tira error con la función time. Solo hay que
utilizar además la librería time.h:
#include<time.h>
Luego guardar el número aleatorio en alguna parte:
num=rand();
Eso es básicamente. Para ajustar el rango de número aleatorios podemos hacer varias
cosas.
Número aleatorios entre 0 y 50:
num=rand()%51;
num=1+rand()%(101-1);
num=250+rand()%(421-250);
De forma general es:
variable = limite_inferior + rand() % (limite_superior +1 - limite_inferior) ;
Así que un programa que muestre 10 números aleatorios entre 1 y 10 quedaría así:
#include<stdlib.h>
#include<iostream>
int main()
{
int num,c;
srand(time(NULL));
for(c=1;c<=10;c++)
{
num=1+rand()%(11-1);
cout<<num<<" ";
}
cin.get();
}
Histograma con números aleatorios y asteriscos

Bueno, tal vez el título quedó muy poco descriptivo, pero la idea es pedir un número de
personas, luego se le pediría a cada persona su peso pero nosotros solo vamos a generar un
número aleatorio en determinado rango. Luego se clasificaría a esas personas en rangos de
peso y al final mostrar una tabla que muestre la frecuencia de cada rango con asteriscos, así:
51-60 ***
61-70 **
71-80 ***
80-91 *
91-mas *****
El código en C++ sería así:

#include<stdlib.h>
#include<iostream>
int main()
{
int n,c,c2,peso[500],cat[5]={0},lim;
// n -> numero de personas
// c y c2 para ciclos
// peso[500] arreglo para guardar el peso de las personas
// cat[5] arreglo para guardar el número de personas en cada categoria de
peso
srand(time(NULL)); // Inicializa los números aleatorios
cout<<"Introduce el número de personas: ";cin>>n;
for(c=0;c<=n-1;c++)
{
peso[c]=51+rand()%(120-51); //guarda un número aleatorio del 51 al 120 en
cada elemento del arreglo
// según su valor se aumenta un elemento de nuestro otro arreglo
if(peso[c]>50 && peso[c]<=60)
cat[0]++;
cat[1]++;
cat[2]++;
cat[3]++;
if(peso[c]>90)
cat[4]++;
}
cout<<"\n";
for(c=0;c<=4;c++)
{
switch(c)
{
// segun cada caso imprime algo diferente
case 0:
cout<<"51-60\t";
break;
case 1:
cout<<"61-70\t";
break;
case 2:
cout<<"71-80\t";
break;
case 3:
cout<<"81-90\t";
break;
case 4:
cout<<"90- \t";
break;
}
lim=cat[c]; // no podemos usar un arreglo como limite del ciclo (la
verdad
// no se porque), entonces lo pasamos a una variable normal
for(c2=1;c2<=lim;c2++)
cout<<"*";
cout<<"\n\n";
}
cin.get();cin.get(); // detiene la ejecución al final (es como getch();)
}
A propósito, este programa fue una petición especial de un usuario.
Como identificar un palíndromo en C++

Lo primero que tendríamos que hacer sería quitar los espacios de nuestra cadena. Luego ir
comparando, el primer caracter con el último, el segundo con el penúltimo, etc. Si todos los
caracteres coinciden, es palíndromo, si no, pues no.
#include<string.h>
#include<iostream>
int main()
{
char cadena[50],cadenaf[50]={0},*parte;
int c,len,pal=0;
cout<<"Introduce un palíndromo: "; cin.getline(cadena,50,'\n');
parte=strtok(cadena," "); //
strcat(cadenaf,parte); // quita los espacios de 'cadena' y
while((parte=strtok(NULL," ")) != NULL) // guarda el resultado en 'cadenaf'
strcat(cadenaf,parte); //
len=strlen(cadenaf);
for(c=0;c<=len-1;c++)
{
if(cadenaf[len-1-c]==cadenaf[c]) // comparación del primer caracter con el
pal++; // último, el segundo con el penúltimo, etc
}
if(pal==len) // si todos las caracteres coinciden, sí es palíndromo
cout<<"Sí es palíndromo!";
else
cout<<"No es palíndromo";
cin.get();
}
/*Creado por THEbatzuk*/
Ordenar arreglo de manera ascendente o

descendente (burbuja)
Programa que lee un arreglo de 10 números y los ordena con el método de la burbuja de
manera ascendente o descendente según se elija. Para esto utiliza una función que recibe
el arreglo y la varible ‘ord’ (1=asc, 2=desc), luego utiliza otra función para imprimirlo.
#include<iostream>
int ordenar(int[],int);
int imprimir(int[]);
int main()
{
int c,lista[9],ord;
for(c=0;c<=9;c++)
{
cout<<"Numero "<<c+1<<": "; cin>>lista[c];
}
cout<<"\nAscendente 1\nDescendente 2\n--> Opción: "; cin>>ord;
if(ord==1 || ord==2)
{
ordenar(lista,ord);
imprimir(lista);
}
}
int ordenar(int lista[],int ord)

{
int c1,c2,aux;
for(c1=0;c1<=9;c1++)
{
for(c2=0;c2<9;c2++)
{
if(ord==1)
{
if(lista[c2]>lista[c2+1])
{
aux=lista[c2];
lista[c2]=lista[c2+1];
lista[c2+1]=aux;
}
}
else
{
if(lista[c2]<lista[c2+1])
{
aux=lista[c2];
lista[c2]=lista[c2+1];
lista[c2+1]=aux;
}
}
}
}
return 0;
}
int imprimir(int lista[])

{
int c;
for(c=0;c<=9;c++)
cout<<lista[c]<<" ";
}
Número de letras y espacios que tiene una frase

Este programa lee una frase por medio de cin.getline y con la función strtrok le quita los
espacios. Cada vez que corta la cadena, un contador se aumenta. Al final se obtiene la
longitud de la cadena sin espacios con la función strlen.
/*Programa para contabilizar el número de letras y de espacios
que tiene una frase */
#include<iostream>
#include<string.h>
int main()
{
char frase[100], *parte, frasef[100]={0};
int lng,spc=0;
cout<<"Introduce una frase: "; cin.getline(frase, 100, '\n');
parte=strtok(frase," ");
strcat(frasef,parte);
while((parte=strtok(NULL," ")) != NULL)
{
strcat(frasef,parte);
spc++;
}
lng=strlen(frasef);
cout<<"Tu frase tiene "<<lng<<" letras y "<<spc<<" espacios";
return 0;
}
Saber si un número es primo o no

Anteriormente vimos como imprimir los números primos en un rango determinado por el
usuario, ahora la idea es pedirle al usuario un número y decirle si es primo o no es primo.
#include<iostream>
int main()
{
int num,c,res,nc=0;
cout<<"Introduce un número: "; cin>>num;
for(c=1;c<=num;c++)
{
res=num%c;
if(res==0)
nc++;
if(nc>2)
break;
}
if(nc==2)
cout<<"Es primo";
else
cout<<"No es primo";
}
En sí, es lo mismo que el anterior. Para darle mas presentación podemos hacer que no se
salga a la primera, sino hasta que se introduzca, por ejemplo, un cero. Esto se hace con un
ciclo do while.
#include<iostream>
int main()
{
int num=1,c,res,nc=0,rep=0;
while(num!=0)
{
cout<<"Introduce un número: ";
if(rep==1)
{
cout<<" --> Para salir oprime cero: ";
}
rep++;
cin>>num;
for(c=1;c<=num;c++)
{
res=num%c;
if(res==0)
nc++;
}
if(nc==2)
cout<<"Es primo\n\n";
else
cout<<"No es primo\n\n";
nc=0;
}
}
¿Alguien sabe porqué la variable num empieza en 1 en este caso?
Números primos en un rango

La idea es imprimir en pantalla los números primos entre 1 y un dato introducido por el
usuario. Creo que es la primera vez que usamos un ciclo dentro de otro ciclo en este blog.
Pero en realidad es muy sencillo:
#include<iostream>
int main()
{
int n=0,c=0,c2=0,res=0,nc=0;
cout<<"Introduce el limite de numeros: "; cin>>n;
for(c=1;c<=n;c++)
{
for(c2=1;c2<=c;c2++)
{
res=c%c2;
if(res==0)
{
nc=nc+1;
}
}
if(nc==2)
{
cout<<" "<<c;
}
nc=0;
}
}
El operador % obtiene el residuo de la división de dos números. Por ejemplo:
10 % 3 = 1
Porque el 3 cabe 3 veces en el 10 y le sobra 1.
Explicación:
1. El primer ciclo lleva la cuenta de los números de 1 a n de uno por uno en la
variable c
2. Luego se inicia un ciclo de 1 a c en la variable c2. Este ciclo se hará n veces
porque está dentro de el primer ciclo
3. En la variable res se guarda el residuo de dividir c / c2
4. Si el residuo es cero, se incremento al contador nc
5. Si al terminarse el segundo ciclo el contador nc es igual a 2, significa que el
número es primo y lo imprime
Recuerden que los números primos son los que únicamente se dividen (sin dejar residuo)
entre 1 y entre si mismos
Encontrar el número mayor de un conjunto

Es en realidad muy simple, se trata de pedir un conjunto de números e ir comparandalos
para obtener el mayor. Un problema es que no sabemos la cantidad de números que se van a
pedir, por lo que al principio del programa tenemos que pedir este valor.
#include<iostream>
int main()
{
int n_num=0,num=0,elmayor=0,c=0;
cout <<"Introduce el numero de numeros: "; cin >> n_num;
for(c=1;c<=n_num;c++)
{
cout <<"\nIntroduce el numero " << c <<": "; cin >> num;
if(num>elmayor)
{
elmayor=num;
}
}
cout <<"\n\tEl numero mayor fue el " << elmayor;
return 0;
}
Una parte importante es la estructura del ciclo:
for(c=1;c<=n_num;c++)
Significa que el ciclo va de 1 hasta ‘lo-que-nos-diga-el-usuario’.
Otra cosa es que usamos iostream y no usamos conio.h.
Cómo empezar a usar iostream

Programar es como pensar, cada quien lo hace diferente, y el mismo lenguaje c++ nos
facilita diversas formas de hacer las mismas cosas. Por ejemplo, el programa Hola Mundo que
hicimos al principio podemos hacerlo utilizando la librería <iostream> en lugar de <stdio.h>:
#include<iostream>
using namespace std; // Esta línea es necesaria cuando
// utilizamos la librería iostream
int main()
{
cout << "Hola Mundo!"; //cout es el equivalente de printf,
//si se fijan la sintáxis es muy parecida.
cin.get(); // cin.get es el equivalente de getch, detiene la ejecución del
programa.
return 0; // No es necesaria para que el programa funcione,

// pero es una buena costumbre indicar que nuestro programa terminó
// sin errores.
}
La sintáxis de cout es:
cout << "mensaje" ;
Mostrando una variable:
cout << "El promedio es:" << prom ;
El siguiente mensaje aparecerá en una línea nueva:
cout << "mensaje" << endl;
¿Y cómo leo datos (scanf)?

Para sustituir scanf() usamos cin, por ejemplo:
cin >> edad;

Lee los caracteres introducidos y los guarda en la variable edad.
Un programita muy simple:

#include<iostream>
int main()
{
int edad;
cout<<"Cual es tu edad?: "; cin >> edad;
cout<<"\n\tTu edad es " << edad;
return 0;
}
En este caso necesitamos usar dos cin.get para detener el programa. Esto se debe al uso de
cin.
Cómo dejar de usar conio.h

La librería <conio.h>, es propiedad de Borland y sólo sus compiladores pueden usarla. Por lo
tanto significa que conio.h, no es una librería estandar.
La librería conio se utiliza más que nada por sus comandos: getch(), clrscr(), gotoxy(),
textcolor(), y textbackground(), los cuales usamos para darle mejor presentación a nuestros
programas. Pero pensandolo bien, ¿en verdad necesitamos que los programas en consola se
vean bien? La verdad es que no, lo que importa es que funcionen.
Aún así, algunas funciones de la librería conio.h se pueden sustituir con funciones
estándares, por ejemplo.
 Para sustituir getch(), solo necesitamos: cin.get(); la cual está en <stdio.h>. Si

no funciona entonces tendremos que ponerla dos veces: cin.get();cin.get();, la
cuestión es algo complicada de explicar.
 Para sustituir clrscr(), solo necesitamos escribir system(“cls”); la cual está en
<iostream> (es sin .h, se definiría así: #include<iostream>).
 Gotoxy() es algo vanal, y además se puede sustituir usando \n (espacio hacia
abajo) y \t (espacio hacia la derecha) dentro de un printf();
 Y la verdad es que cualquiera te agradecerá que no le pongas fondo rosa y letras
amarillas a tus programas.
Como usar ciclo While en C++

Ya dijimos en el post anterior que los ciclos infinitos for son muy parecidos a los ciclos
while, pero quedó en duda cómo es un ciclo while.
“While” significa “mientras“, así que nuestro ciclo while se repetira mientras una cierta
condición siga siendo verdadera.El ejemplo del post anterior quedaría así:
#include<stdio.h>
#include<conio.h>
int main()
{
char end=0;
while(end!='y')
{
gotoxy(5,5);printf("Ya quieres salir? (y/n): ");scanf("%c",&end);
clrscr();
}
}
En español el programa dice: “Mientras end sea diferente de y voy a seguir preguntando si
quieres salir.”
Mas adelante veremos más programas que utilicen ciclos while.
El break y el ciclo infinito

Ya vimos hace poco el ciclo for, y vimos que su estructura era así:
for ( inicio ; fin ; aumento )
¿Qué pasa si no ponemos ni inicio ni fin? Pues obtenemos un ciclo infinito, así:
for(;;)
¿Y cómo se detiene? Pues con un break, así:
for(;;)
{
break;
}
¿Y esto de que me sirve? Pues la idea es repetir las instrucciones hasta que el usuario quiera,
es decir:
#include<stdio.h>
#include<conio.h>
int main()
{
char end=0;
for(;;)
{
gotoxy(5,5);printf("Ya quieres salir? (y/n): ");scanf("%c",&end);
if(end=='y')
break;
clrscr();
}
}
Creo que no les había mencionado que si dentro de una condición if sólo va una instrucción
no es necesario poner llaves, y también aplica con los ciclos.
Si el usuario no introduce una ‘y’, el programa nunca se detendrá. Luego vamos a ver que las
propiedades de un ciclo for infinito son muy parecidas a las del ciclo while que veremos
más adelante.
Programa: Porcentaje de Hombres y Mujeres
Supongamos que nos preguntan qué porcentaje de hombres y qué porcentaje de mujeres
hay un salón de clases. Lo primero que tenemos que hacer es preguntar el total de personas
que hay, luego hacer un ciclo que en cada iteración pregunte el sexo de cada alumno. En
base a esos datos se calculan los porcentajes.
El programa en c++ sería así:

#include<stdio.h>
#include<conio.h>
int main()
{
float total=0,ciclo=0,conta_h=0,conta_m=0,porc_h=0,porc_m=0;
char mof;
gotoxy(5,5);printf("Cuantos alumnos hay en este grupo?: ");scanf("%f",&total);
for(ciclo=1;ciclo<=total;ciclo++)
{
clrscr();
PREG: gotoxy(10,6);printf("Sexo de alumno %.f? (M o F):
",ciclo);scanf("%c",&mof);
if(mof=='m' || mof=='M')
conta_h++;
else if(mof=='f' || mof=='F')
conta_m++;
else
goto PREG;
}
//Calculos
porc_h=conta_h/total*100;
porc_m=conta_m/total*100;
//
gotoxy(5,5);printf("El porcentaje de hombres es %.1f (%.f de
%.f)",porc_h,conta_h,total);
gotoxy(5,6);printf("El porcentaje de mujeres es %.1f (%.f de
%.f)",porc_m,conta_m,total);
getch();
}
Cómo usar goto en C++

Goto significa ir a y en c++ nos sirve para que mandar al compilador a alguna parte
arbitrariamente, es decir nada más porque sí. No se suele usar mucho pero nos puede sacar
de algunos apuros.
Su uso es más o menos así:

codigo codigo
LUGAR: codigo
mas codigo
codigo
goto LUGAR;
codigo
Primero tenemos que definir un marcador, en este caso yo usé LUGAR (recuerden que
‘LUGAR’ no es lo mismo que ‘lugar’) e inmediatamente después poner dos puntos (:).
Cuando sea necesario escribiremos goto seguido de nuestro identificador y punto y como (;).
¿Para qué nos podría servir? Pues en el siguiente post veremos un programa que usa goto.
if else anidados en c++

Ya había escritos varios posts sobre las condiciones if else en c++, pero algo que hace falta
saber es que dentro de una estructura if puede haber otra estructura if tantos veces como
sea necesario. Es decir:
if ( condicion )
{
instrucciones
if ( condicion )
{
instrucciones
}
}
else
{
if ( condicion )
{
instrucciones
}
else
{
instrucciones
}
instrucciones
}
¿Y como para qué? Pues hay algunas situaciones que así lo requieren. Por ejemplo:
“Si un alumno tiene un promedio mayor o igual a 9 se le hara un 20% de descuento en la

colegiatura, si tiene un promedio mayor o igual a 8 pero menor que 9 el descuento será del
10%, si su promedio es menor que 8 pero mayor o igual a 7 el descuento será del 5% y si
promedia con 7 o menos no tendrá descuento.”
La solución de este problema en c++ sería así:
Seguir leyendo…
Programa: Recuadros en C++

Ya que sabemos usar los ciclos for y el gotoxy, vamos a hacer un programa que muchos
profesores encargan: un recuadro en c++, es decir, un margen o contorno para darle mas
presentación a un programa.
En realidad es muy sencillo:

#include<stdio.h>
#include<conio.h>
int main()
{
int x=0;
for(x=1;x<=80;x++)
{
gotoxy(x,1);printf(".");
gotoxy(4,23);printf("Nombre: Programa: Numero: ");
if(x<=24)
{
gotoxy(1,x);printf(".");
gotoxy(80,x);printf(".");
}
}
getch();
}
Modifíquenlo, échenle imaginación. Yo use puntos (.), pero ustedes pueden usar cualquier
otro caracter.
Programa: Tabla ASCII en C++ (sencillo)

Bien, ahora que ya vimos algo de teoría y práctica sobre ciclos en c++, vamos a hacer un
programa que nos muestre el código ASCII del 1 al 256. Por si no los saben, las
computadoras solo ‘entienden’ números, así que cada letra y cada caracter es en realidad un
número; eso es el código ASCII.
Así que el programa sería así:

#include<stdio.h>
#include<conio.h>
int main() {
int ascii=0,col=1,ren=1;
for(ascii=1;ascii<=256;ascii++) {
gotoxy(col,ren);printf("%i: %c ",ascii,ascii);
if(ren==24) { ren=0; col+=12; }
if(col>=80) { getch(); clrscr(); ren=0; col=1; }
ren++;
}
getch();
}
Variables:
 ascii -> Controla el ciclo desde 1 hasta 256

 ren -> Controla los renglones
 col -> Controla las columnas
Cuando ren==24, los renglones comienzan en cero de nuevo y se empieza en una nueva
columna; cuando col>=80, se detiene el transcurso del ciclo, luego se limpia la pantalla y se
reinician los renglones y las columnas.
Cómo usar Gotoxy en C++

Gotoxy significa go to (x, y), es decir ir a (x, y), donde (x, y) es una coordenada de nuestra
pantalla. Se suele usar antes de un printf, para poner el texto en una cierta parte de la
pantalla.
La pantalla de C++, tiene 24 renglones y 80 columnas, por lo que los valores que le pongamos
a nuestro gotoxy no deberán pasar de esos valores.
¿Cómo usar gotoxy()?

Su sintáxis es la siguiente:
gotoxy ( columna , renglón ) ;
Así, si queremos que un mensaje salga en la parte inferior de la pantalla, nuestro programa
sería el siguiente:
#include<stdio.h>
#include<conio.h>
int main() {
gotoxy(5,24);printf("Hola mundo");
getch();
}
¡Qué fácil! ¿no?
Ciclos for en C++

Bien, ya que entendimos un poco la teoría de los ciclos en c++, ahora vamos a practicar
sobre como usar el ciclo for.
¿Cómo hacer un ciclo en C++?

#include<stdio.h>
#include<conio.h>
int main()
{
int x=0;
for(x=0;x<=5;x++)
{
printf("%d ",x);
}
getch();
}
//Este programa mostrará en pantalla 0 1 2 3 4 5
Como ven, necesitamos una variable exclusiva para el ciclo (en este caso ‘x’) y éste empieza
con la palabra for, su sintáxis es la siguiente:
for ( variable = inicio-del-ciclo ; condición-que-indica-el-final ; aumento de x )
Por partes:
 x=0 -> Indica el inicio del ciclo. Puede ser cualquier variable y cualquier valor
de inicio.
 x<=5 ->Indica el fin del ciclo. Cuando la condición deja de cumplirse el ciclo
termina. Cuando el ciclo no es menor o igual a 5 el ciclo termina.
 x++ -> Indica que la variable ‘x’ aumenta de uno en uno. Para aumentar de dos
en dos: x+=2, de tres: x+=3.
Otro ejemplo, la tabla de multiplicar del 2 en C++:

#include<stdio.h>
#include<conio.h>
int main()
{
int c=0;
for(c=1;c<=10;c++)
{
printf("2 x %d = %d\n",c,2*c);
}
getch();
}
Entendiendo los ciclos en c++
Como les dije en el programa anterior (¿Aprobó o no aprobó?), los ciclos son algo que un
buen programador debe tener muy bien dominado. Pero…
¿Qué es un ciclo?
Un ciclo, aquí y en China, es algo que se repite constantemente. Por ejemplo:
 Si vamos a la papelería y sacamos 5 copias de una hoja, cada vez que se imprime
una hoja se completa un ciclo y se repite hasta completar las cinco repeticiones
 Si saben algo de guitarra, abran oído del ‘círculo de sol’; son cuatro acordes que
se repiten constantemente a lo largo de una canción, cada vez que tocas los cuatro
acordes se completa un ciclo
 Si ponen un CD de música en un reproductor, cada vez que suenen todas las
canciones del disco se completa un ciclo
¿Cómo serían los programas de esos ejemplos?

Para sacar copias
Desde x=1 hasta 5
{
imprimir
}
Para tocar el círculo de Sol
Desde x=1 hasta fin de la canción
tocar Sol
tocar Mi menor
tocar La menor
tocar Re 7
Para tocar CD
Desde x=1 hasta número de canciones
{
tocar canción x
Los primeros dos están muy fáciles de entender: las acciones dentro de las llaves {} se
repiten determinado número de veces y ese valor puede ser constante (como las copias) o
variable (como el fin de la canción). El tercer ejemplo tiene algo complicado, pero que es la
‘escencia’ de los ciclos.
Supongamos que ese disco tiene 5 canciones, podríamos programarlo así:
tocar canción 1
tocar canción 2
tocar canción 3
tocar canción 4
tocar canción 5
O así:
Desde x=1 hasta 5

{
tocar canción x
Esta es la verdadera utilidad de los ciclos, ahorrar código.
Programa: ¿Aprobó o no aprobó?

También es muy común entre los profesores, encargar este tipo de programas una vez que se
ven las condiciones. De lo que se trata es de pedir, por ejemplo, 3 calificaciones, sacar el
promedio y mostrar un mensaje si el alumno aprobó o no aprobó.
Como el promedio puede ser una valor con decimales, tenemos que declarar las variables
como tipo float.
#include<stdio.h>
#include<conio.h>
int main()
{
float calif_1=0,calif_2=0,calif_3=0,promedio=0;
printf("\nIntroduce tu primera calificacion: ");scanf("%f",&calif_1);
printf("\nIntroduce tu segunda calificacion: ");scanf("%f",&calif_2);
printf("\nIntroduce tu tercera calificacion: ");scanf("%f",&calif_3);
promedio=(calif_1+calif_2+calif_3)/3;
if(promedio<6)
{
printf("\n\tLo siento, tu promedio de %.2f no es aprobatorio",promedio);
}
else
{
printf("\n\tFelicidades, pasaste con un %.2f",promedio);
}
getch();
}
Aquí estamos asumiendo que la calificación mínima aprobatoria es de 6, pero ¿y si quiero que
este dato también sea variable? Entonces el programa quedaría así:
Seguir leyendo…
Programa: ¿Qué tipo de triángulo es?

Ok, hasta hoy ya hemos visto las herramientas necesarias para hacer nuestro primer
programa un poco más en serio. Este programa nos pide la medida de los tres lados de un
triángulo y nos devuelve el tipo de triangulo que es (equilátero, isósceles o escaleno).
Para esto vamos a usar condiciones en C++ para comparar los lados de nuestro triángulo.
Un tríangulo equilátero tiene sus tres lados iguales, por tanto, la condición quedaría así:
“si el lado 1 es igual al lado 2 y el lado 2 es igual al lado 3, entonces es equilátero”
Un tríangulo isósceles tiene solo dos lados iguales, por tanto, la condición quedaría así:
“si el lado 1 es igual al lado 2 y el lado 2 es diferente al lado 3, o
el lado 2 es igual al lado 3 y el lado 3 es diferente al lado 1, o
el lado 3 es igual al lado 1 y el lado 1 es diferente al lado 2 entonces es isósceles”
Un tríangulo escaleno tiene sus tres lados diferentes, por tanto, la condición quedaría así:
“si el lado 1 es diferente al lado 2 y el lado 2 es diferente al lado 3 y el lado 3 es diferente al

lado 1, entonces es escaleno”
Pero vamos a lo bueno. El programa completo en C++, sería así:

#include<stdio.h>
#include<conio.h>
int main()
{
//Declaracion de variables
int lado1=0,lado2=0,lado3=0;
//Pedir los datos

printf("TIPOS DE TRIANGULOS");
printf("\nIntroduce el lado 1: ");scanf("%i",&lado1);
//Hacer comparaciones
if(lado1==lado2 && lado2==lado3)
{ printf("\n\tEs equilatero"); }
if(lado1==lado2 && lado2!=lado3 || lado2==lado3 && lado3!=lado1 || lado3==lado1
&& lado1!=lado2)
{ printf("\n\tEs isosceles"); }
if(lado1!=lado2 && lado2!=lado3 && lado3!=lado1)
{ printf("\n\tEs escaleno"); }
//Pausa
getch();
}
Aprovecho para explicarles un detalle más. \n (alt+92 n) dentro de un printf(); indica un

salto de línea, y \t (alt+92 t) indica una sangría o tabulado o algo de espacio.
Bajar Dev-C++ gratis (compilador para C++)

Ya les proporcioné antes un enlace para bajar Borland C++ 6.0, pero no hay nada como lo
legal, y Bloodshed Dev C++ lo puedes descargar de forma totalmente gratuita (y legal)
desde su propia página, o para ahorrarles clics, desde SourceForge: Dev-C++.
Es un software excelente, muy actual, con una buena interfaz y funciona a la perfección. El
único problema es que no podremos usar la librería <conio.h> (porque es propiedad de
Borland) a menos que sigamos las siguientes instrucciones: conio en Dev-C++.
Ya por último les pongo la captura de pantalla de Dev-C++ con lo básico que debrían de
saber:
Condiciones (decisiones) en C++ – if, else
¿Cómo harían para saber si alguien es mayor o menor de edad? Creo que los pasos serían:
1. Preguntarle su edad
2. Si tiene 18 o más entonces es mayor de edad
3. Si no, es menor de edad
Metiendonos al lenguaje de C++, quedaría algo así:
1. scanf(“%d”, &edad);
2. if(edad>=18) { printf(“Es mayor de edad”); }
3. else { printf(“Es menor de edad”); }
if significa si y else significa si no
edad>=18 es una comparación. Si la variable ‘edad’ es mayor o igual a 18, se hacen las
instrucciones que están entre las llaves {} del if; si no es así, se realizan las instrucciones
que están entre las llaves del else.
El programa en sí quedaría de la siguiente forma:

#include<stdio.h>
#include<conio.h>
int main()
{
int edad=0;
printf("Cual es tu edad?: "); scanf("%d",&edad);
if(edad>=18)
{
printf("Eres mayor de edad");
}
else
{
printf("Eres menor de edad");
}
getch();
}
Un if no tiene que tener un else ‘a fuerzas’, es opcional. Es muy importante que se fijen muy
bien en las llaves, cada if tiene su llave de apertura y de cierre, al igual que el else.
Pedir datos en C++ – scanf()

Hasta ahora, todo los ejemplos que hemos visto usan datos que nosotros mismos le ponemos
la programa, pero ¿qué hacer si necesito que el usuario sea quien introduzca los datos de
entrada?
Al igual que printf() muestra datos, scanf() los guarda.
Ejemplo:
#include<stdio.h>
#include<conio.h>
int main()
{
int edad=0;
printf("Cual es tu edad? ");scanf("%d",&edad);
printf("Tu tienes %d anios", edad);
getch();
}
El scanf() guarda en la variable indicada todo lo que introduzcas desde el teclado hasta que
oprimas ‘enter’. Su sintáxis tiene que ser exacta:
scanf ( ” tipo-de-dato ” , & variable ) ;
scanf ( ” %d ” , & edad ) ;

scanf() es sin duda una de las instrucciones que más estaremos usando, ya que la interacción
con el usuario es fundamental en el desarrollo de programas.
Operadores lógicos en C++

Con operadores de relación nos referimos a los ya conocidos:
 < (menor que)

 <= (menor o igual que)
 > (mayor que)
 >= (mayor o igual que)
 == (igual)
 != (diferente)
Bueno, talvéz los operadores de igual (==) y diferente (!=) no los hayan visto escritos así,
pero en C++ así se representan.
Una expresión con operadores de relación (por ejemplo: a<b, a!=b) únicamente nos dice si la
evaluación es verdadera (true) o falsa (false).
También están estos otros:
 and, que significa ‘y’ y se representa con &&

 or, que significa ‘o’ y se representa con || (alt+124 dos veces)
Sirven para relacionar dos o más operaciones lógicas. Al usar && (y), las dos operaciones
tienen que ser verdaderas para que arroje un resultado verdadero, si no, es falso. Al usar ||
(o), las dos operaciones tienen que ser falsas para que arroje un resultado falso, si no, es
verdadero.
Ejemplos
Si a=4 y b=5 entonces,
 a==b es false
 a>b es false
 a!=b es true
 a==b && a<b es false
 a==b || a<b es true
Operaciones en C++
Bien, ya sabemos declarar y mostrar variables, ahora solo falta saber cómo hacer
operaciones matemáticas con ellas. Una suma sería así:
#include<stdio.h>
#include<conio.h>
int main()
{
int num1=5, num2=10, resultado=0;
resultado=num1+num2;
printf("El resultado es: %i", resultado);
//Esto mostrará en pantalla: El resultado es: 15
getch();
}
Como ven, siempre hay que tener una variable para guardar el resultado de cualquier
operación. En algunos casos se puede usar la misma variable:
#include<stdio.h>
#include<conio.h>
int main()
{
int num1=5;
num1=num1+6;
printf("El resultado es: %i", num1);
//Esto mostrará en pantalla: El resultado es: 11
getch();
}
Entonces, los signos de operación en C++ y la mayoría de los lenguajes de programación

son:
 + para suma
 - para resta
 * para multiplicación
 / para división
 () también indican multiplicación
Variables en C++ 2 – Mostrar variables

Ya sabemos como agregar variables a nuestros programas, ¿pero cómo se usan?
Para mostrar el valor de una variable en pantalla con printf() se usan los caracteres de
sustitución. Vean este programa:
#include<stdio.h>
#include<conio.h>
int main() //Esta es la función main, va en todos los programas
{
int numero=7; //A la variable numérica 'numero' le asignamos un valor de 7
printf("El numero es %i", numero); //Esto mostrará en pantalla: El número es 7
getch(); //Hace una pausa
}
Como ven, el valor de la variable aparece en lugar de %i, cada tipo de dato tiene su propio
caracter de sustitución.
 Para int se usa %i o %d

 Para float se usa %f
 Para char se usa %c
Otros ejemplos:
#include<stdio.h>
#include<conio.h>
int main()
{
int edad=17;
float altura=1.67;
printf("Edad: %i años, altura: %f metros", edad, altura);
//Esto mostrará en pantalla: Edad: 17 años, altura: 1.670000 metros
getch();
}
Para mostrar datos float, podemos usar este ‘truco’:
 %f mostrará 0.000000
 %.2f mostrará 0.00
 %.1f mostrará 0.0
 %.f mostrará 0
Variables en C++ 1 – Lo básico

Parte fundamental de cualquier lenguaje de programación son las variables. Si sabes algo de
álgebra, por variable te imaginarás una letra que puede tener varios valores. En
programación ésto no cambia mucho, solo que una variable puede tener un nombre
completo, no solo una letra.
Ejemplos de nombres variables

 x
 contador
 primer_nombre
 num_primo
Una variable no puede tener espacios, caracteres especiales (acentos, signos), tiene que
empezar con una letra.
Ejemplos de valores variables

 x=12
 contador=0
 primer_nombre=”Juanito Gómez”
 num_primo=7
Las variables se usan para almacenar valores que cambian dinámicamente en el transcurso
del programa.
Como declarar una variable en C++
C++ maneja varios tipos de variables: numéricas, de caracteres y boolean (cierto o falso)
esencialmente.
Para declarar una variable numérica llamada altura que inicie con un valor de 0, escribimos
esto:
int altura=0;
Para declarar una variable numérica llamada distancia que inicie con un valor de 2.67,
escribimos esto:
float distancia=2.67;
Para declarar una variable de caracter llamada inicial, con un valor de R, escribimos esto:
char inicial='R';
Para declarar una variable boolean llamada terminado, que empiece como falso, escribimos
esto:
bool terminado=false;
En resumen:
 Para variables numéricas sin decimales se usa: int

 Para variables numéricas con decimales se usa: float
 Para variables de un solo caracter se usa: char
 Para variables boolean se usa: bool
Como declarar varias variables en C++

Solo se pone el tipo de dato (int, float, char, bool) y separamos las variables con comas.
int num=0, personas=16, lugares=10;
Siempre va un punto y coma (;) al final de la declaración de variables.
Algo de teoría para hoy, después vendrá la práctica.
Comentarios en C++
Un comentario es una nota que puedes poner en cualquier parte de tu programa y que será
totlamente ignorada a la hora de correr el programa. Son bastante útiles para que otras
personas, o tú mismo después de algún tiempo, sepan qué hace alguna parte de tu código.
Un comentario en C++ se puede hacer de dos formas:
 Para comentarios de una sola línea: // El comentario

 Para comentarios de varias líneas: /* El comentario */
Por ejemplo:
/* Autor: Raúl Rivas
Fecha: Agosto de 2009 */
#include<stdio.h>
#include<conio.h>
int main()
{
//Aquí declaro mis variables
int numero1=10;
printf("%i",numero1); //esto mostrará: 10
getch();
}
Facil ¿no?
Hola Mundo, en C++

Es como un rito de iniciación empezar con un programa que sencillamente muestre el
mensaje: “Hola Mundo” en pantalla, hoy lo vamos a hacer en c++.
#include<stdio.h>
#include<conio.h>
int main() {
printf("Hola Mundo");
getch();
}
 La primera y segunda líneas son librerías. Una librería es el lugar en dónde están
definidas cientos de funciones que utilizaremos continuamente. stdio.h y conio.h son
las librerías que vamos a estar usando continuamente.
 main() es la función principal, todo el programa se desarollará a partir de ella.
Esta función está seguida de una llave de apertura ({), y al final hay una de cierre (}).
Esto significa que todo lo que está entre las llaves pertenece a main().
 printf(); es una función para imprimir (mostrar) datos en pantalla. Entre
comillas escribimos lo que queremos mostrar. Está definida en stdio.h
 getch(); es una función definida en conio.h que detiene la ejecución del
programa para que el usuario pueda apreciar los resultados.
C++ busca automáticamente la función main(), y si esta no se encuentra, sencillamente no

funcionará el programa.
Hay que tener muy presente que las funciones ‘menores’ siempre terminan con punto y
coma (;). Este símbolo marca el final de toda sentencia.
Curso de C++
¡Bienvenidos a mi curso de C++!, en realidad esto es sólo una sección del blog donde pueden
consultar una serie de posts que ya había hecho anteriormente, pero de un forma ordenada,
empezamos desde lo más básico y vamos avanzando poco a poco. Yo se que es muy fácil
darle clic a ‘Siguiente’, pero si de verdad quieren aprender no lo hagan hasta que hayan
comprendido el post y hayan hecho alguna práctica sobre ello.
Recuerden que en el curso no están todos los posts del blog, si alguna entrada les pareció
interesante pueden checar los posts relacionados (abajo de cada post) para leer otros posts
del mismo tema. Y creo que no están ordenados muy muy bien, pero creo que eso ayuda un
poco a hacer menos monótono el aprendizaje :)
Así que aquí abajo está el índice, o pueden dar clic en siguiente (aquí en la barra lateral ->)
para comenzar desde el primero; iré agregando más temas de vez en cuando.
¿Porqué programar en C++?
De seguro mas uno te ha dicho: “¿C++?, eso ya está obsoleto”, pero la realidad es muy
distinta.
Imagínense que programar es como escribir. En un lenguaje de alto nivel (visual) tienes
todas las palabras del mundo pre-escritas, listas para que las agarres y las uses. En un
lenguaje de nivel medio (como c++), tienes todas las letras del alfabeto listas para que
formes la palabra que quieras. En un lenguaje de bajo nivel (ensamblador) tendrías tu mismo
que ‘hacer’ cada letra.
Cada uno tiene sus ventajas, pero la verdad es que para empezar a aprender a programar,
C++ es perfecto.
Y si todavía tienes dudas, acuérdate que sistemas operativos como Linux, Unix e incluso
Windows (anteriormente), se escriben casi por completo en C.
¡Hola programadores en C++!

Codigo C++ es un blog en el que voy a intentar ayudar a todos quienes tengan en su escuela,
bachillerato, preparatoria, tecnológico o universidad clase de programación y estén
empezando a programar con C++.
Cada post tendrá un programa en C++ explicado lo más detallado posible y además varias
formas de hacerlo. Posibles problemas y errores serán tomados en cuenta y los comentarios
estarán siempre abiertos para que cada quien exprese sus dudas.

Curso de C++

Cargado por

Copyright:

Formatos disponibles

Curso de C++

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso de C++

Cargado por

Copyright:

Formatos disponibles

Curso de C++

A mí cuando me enseñaron a programar me dijeron que iba a aprender a programar en C++,

Pedir un dato en C++

Mostrar un dato en C++

Libreria en C Librería en C++

#define en C++, cómo sí y cómo no

Tenemos 6 definiciones, ordenadas en su nivel de aceptabilidad:

 #define PI 3.14159265 y #define NOF_CHAR 50, éstos ejemplifican el uso

Nuevo: Curso de C++

Code::Blocks, un IDE moderno para C++

Code::Blocks tiene bastante ventajas respecto a otros IDES:

 Aspecto moderno. ¿A quién le gusta programar a pantalla completa en consola

Lo pueden descargar aquí: Download Code::Blocks. Asegúrense de descargar la versión que

Aprender inglés, ¿¡en C++!?

 Obtener los pares de palabras desde una base de datos

Números aleatorios sin repetir en C++

1. Crear una matriz y dejarla vacía.

Así que el programa es este:

Pero bueno, el programa es este:

Cuando inicializar las variables en cero y cuando no

Vamos a ver si la leyenda es cierta:

Simular una Progress Bar en C++

La función delay() o Sleep()

cout << "Hola" << endl;

Se muestra 'Hola', se pausa 2 segundos y se muestra 'Hace dos segundos te saludé!'

Saber si es palíndromo o no, de forma recursiva 2da

Comenté extensivamente el código, así que aquí está:

Saber si es palíndromo o no, de forma recursiva

Bueno pues el código es este:

El código ahora es más eficiente por dos simples razones:

1. Se detiene y da el resultado a la primera comparación de caracteres que no sean

Imprimir determinados números primos

Ok, el código es este:

Únicamente ponemos la palabra while en lugar de for, copiamos la condición que

No se hacen proyectos finales

Clasificar números en C++

“Genere 10 números aleatorios del 0 al 50 y los clasifique en 2 rangos: menores que 10 y

Tenemos 3 matrices, en la primera guardamos nuestros 10 números aleatorios, en la segunda

Convertir segundos a horas, minutos y segundos

Ya sólo mostramos las tres variable y listo.

Operadores compuestos en C++

Como ven está inspirado en hacer que ‘lo-primero-que-se-nos-ocurre’ sea posible.

Así tenemos que:

mivar = mivar + 3; es lo mismo que mivar += 3;

Si, por ejemplo, num = 3, entonces la instrucción n+=num se desarrolla así:

Tipos de funciones en C++

Así nuestro programa sería:

‘tipo’ y ‘nombre’ se refieren a lo mismo y como no retorna el tipo siempre es void.

Dentro del paréntesis tenemos otros aspectos:

‘tipo_var1′ se refiere al tipo de la variable que nuestra función va a recibir.

‘nombre_var1′ se refiere al nombre de esa variable.

Nuestro programa quedaría así:

void sumar(int num1, int num2)

tipo nombre() { return var; }

Nuestro programa quedaría así:

¿A alguien se le ocurre una función conocida de este tipo?

Nuestro programa quedaría así:

int sumar(int num1, int num2)

Bueno, no me iba a quedar tranquilo si no les mostraba la versión optimizada de la última

int sumar(int num1, int num2)

int x, y; y = sin(i/180PI)10; gotoxy(x,y);