Código 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 Victor, 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>
using namespace std;
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 Victor, entonces tal vez te interese este post: Cómo contar el número de veces que sucede algo.

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>
using namespace std;
 
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;
  cin.get();cin.get();
 
  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.

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();
}

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.

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…

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);
  printf("\nIntroduce el lado 2: ");scanf("%i",&lado2);
  printf("\nIntroduce el lado 3: ");scanf("%i",&lado3);
 
  //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.

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.