marzo, 2021 - cplusplus.es

Operaciones Aritméticas

Las operaciones aritméticas básicas en C++ son muy parecidas a las de otros lenguajes.

Operador	Operación
+	Suma
–	Resta
*	Multiplicación
/	División
%	Módulo

Una librería muy útil a la hora de realizar operaciones matemáticas es cmath. Una de sus funciones más útiles es pow().

Fíjate en su uso:

#include <cmath>

std::pow(base, exponente);

Como por ejemplo:

std::pow(2, 5);

cmath incluye también algunas constantes muy útiles a la hora de realizar operaciones matemáticas, como por ejemplo M_PI que es el equivalente al número PI.

M_PI = 3.14159265358979323846

Conversiones implícitas

Como ya sabes, C++ es un lenguaje compilado y como tal requiere conocer los tipos de variable que van a ser usados durante la ejecución.

Sin embargo se permiten ciertas conversiones implícitas, como por ejemplo un entero que se asigna a una variable de tipo float o un entero tratado como un char.

Echa un vistazo al siguiente ejemplo para comprender mejor este concepto:

#include<iostream>

int main()
{
    
    int a = 65;
    char charA = 65;
    char charB = 'B';
    float answer = 0;
    char charC = 67;
    int integer = 80;
    float floatNumber = 0.0;
    
    std::cout<<"a = "<<a<<"\n";
    std::cout<<"charA = "<<charA<<"\n";
    std::cout<<"charB = "<<charB<<"\n";
    
    // se puede asignar un integer a un float 
    floatNumber = integer;
    std::cout<<"integer = "<<integer<<"\n\n";
    std::cout<<"floatNumber = integer = "<<floatNumber<<"\n";
    
    // se puede asignar un char a un float
    floatNumber = charB;
    std::cout<<"floatNumber = charB = "<<floatNumber<<"\n";  
    
    answer = floatNumber/4;
    std::cout<<"respuesta = floatNumber/4 = "<<answer<<"\n"; 
    
    // Asignar un float a un char no funciona tan bien...
    charC = answer;
    std::cout<<"charC = respuesta = "<<charC<<"\n";
    
    // y si asignas un float a un integer el valor s truncado
    integer = answer;
    std::cout<<"integer = floatNumber = "<<integer<<"\n";   
    return 0;
}

Prefijo y postfijo

En C++, como en otros lenguajes, hay operadores que pueden funcionar como prefijos y postfijos.

Para incrementar una variable:

prefijo: ++a
postfijo: a++

Para reducir:

prefijo: –a
postfijo: a–

Existe una diferencia pequeña pero crucial entre ambas y es que el prefijo modifica el valor de la variable y después la devuelve y el postfijo crea una copia de la variable, la modifica y devuelve una copia anterior a la modificación.

Entrada y salida de datos II

Ya hemos visto anteriormente (lección anterior aquí) que para escribir en la consola usamos std::cout. De forma muy parecida tenemos std::cin para capturar la entrada desde la consola. Prueba un ejemplo:

#include <iostream>
#include <string>

int main()
{
  int pokNumber = 0;
  int pokPs = 0;
  std::string pokemon = "";
  
  std::cout<<"¿Cuántos pokemon tienes? ";
  std::cin >> pokNumber;
  
  std::cout << "No está mal, yo tengo " << pokNumber + 1 << std::endl;
  
  std::cout << "¿Cuántos PS tiene tu pokemon más fuerte? ";
  std::cin >> pokPs;
  
  std::cout<<"Está muy bien, mi Pikachu tiene "<< pokPs + 10 << " PS" << std::endl;

  std::cout<<"¿Cuál es tu pokemon favorito? ";
  std::cin >> pokemon;
  
	std::cout << "Qué casualidad! Mi pokemon favorito también es " << pokemon << std::endl;

	return 0;
}

¿Qué sucede al intentar capturar la entrada del usuario si se introducen dos palabras?

Te invito a que lo pruebes en tu propio programa y veas el resultado.

Podemos comprobar como std::cin no está pensado para capturar cadenas largas o espacios. Para ello tenemos a nuestra disposición una función llamada getline.

Su forma básica de operar es la siguiente: captura caracteres de std::cin y los almacena en la variable asignada. Se realiza esta operación hasta alcanzar una línea nueva o bien el carácter asignado, por defecto ‘\n’. Más info aquí.

#include<iostream>
#include<string>

int main()
{
    std::string apodo; 
    std::cout<<"¿Cuál es tu apodo?: ";
    std::getline(std::cin, apodo);
    std::cout<<"Hey, "<<apodo<<"!\n";
    return 0;
}

Stringstream

Esta librería resulta muy útil a la hora de manipular cadenas. Stringstream permite la manipulación de variables como si fueran streams de datos.

Para utilizarla debemos incluir la cabecera:

#include <sstream>

Fíjate en el siguiente ejemplo:

#include <string>
#include <iostream>
#include <sstream>

int main () {

  std::stringstream ss;

  ss << "pikachu" << ' ' << "bulbasaur";

  std::string pika, bulbasaur;
  ss >> pika >> bulbasaur;

  std::cout << "pokemon 1: " << foo << '\n';
  std::cout << "pokemon 2: " << bar << '\n';

  return 0;
}

Archivos de cabecera

También conocidos como header files. Como ya vimos en lecciones anteriores, podemos incluir todo tipo de librerías adicionales en C++, y podemos crear las nuestras e incluirlas también.

Generalmente los archivos de cabecera tienen la extensión .hpp, pero puedes utilizar la extensión que prefieras. Lo más importante acerca de los archivos de cabecera es que tienes que saber que son usados para definir información sobre como ejecutar una tarea, a diferencia del programa principal, que define lo que se va a ejecutar.

Veamos como un archivo de cabecera funciona con un sencillo programa ‘Hola, mundo!’

#include <iostream>

using namespace std;

int main(){
  cout << "Hola, estamos usando archivos de cabecera!";
  return 0
}

Si quisiéramos usar un archivo de cabecera para este propósito podríamos mover todo el código que no estuviera estrictamente relacionado con la tarea, de forma que podríamos generar un archivo main.hpp con el siguiente contenido:

#include <iostream>

using namespace std;

Y modificaríamos nuestro archivo principal (el que contiene la funcion main) para que quedara de la siguiente manera:

#include "main.hpp"

int main(){
  cout << "Hola, estamos usando archivos de cabecera!";
  return 0
}

Fíjate en las comillas dobles para incluir el archivo. De esta forma indicamos que se encuentra en el directorio actual.

Entrada y salida de datos I

En este artículo vamos a ver como funciona la entrada y salida de datos en C++, también conocida como I/O. En C++ los flujos de datos son llamados Streams y pueden tomar muchas formas: Desde texto que el usuario introduce en la terminal, a la lectura de un sensor de infrarrojos de un robot, pasando por archivos o bases de datos.

Escribir en la consola

Como ya hemos visto en el programa de ejemplo de la primera lección, escribimos en la consola usando ‘cout‘.

Las cadenas de texto tienen que ir entre comillas dobles ‘»‘, las comillas simples »’ denotan un caracter únicamente, es decir, un tipo char. Si utilizamos cout con una variable, el valor de la variable es impreso. Cout puede ser usado multiples veces, encadenando el resultado en una única salida:

int integer = 42;
std::cout<<"El valor del entero es "<<integer;

Es importante señalar que cout no añade un salto de línea de forma automática, para ello debes hacerlo tú poniendo un ‘\n’ al final de la cadena de texto.

Prueba a escribir un programa que imprima por consola el tamaño en bytes de los diferentes tipos de variable. Utiliza la función sizeof() para ello.

Más información acerca de sizeof() aquí.

Dicho programa se podría parecer al siguiente ejemplo:

#include <iostream>
using namespace std;
 
int main()
{
   cout << "Bytes de variable char : " << sizeof(char) << endl;
   cout << "Bytes de variable int : " << sizeof(int) << endl;
   cout << "Bytes de variable short int : " << sizeof(short int) << endl;
   cout << "Bytes de variable long int : " << sizeof(long int) << endl;
   cout << "Bytes de variable float : " << sizeof(float) << endl;
   cout << "Bytes de variable double : " << sizeof(double) << endl;
   cout << "Bytes de variable wchar_t : " << sizeof(wchar_t) << endl;
  
   return 0;
}

Fíjate sobre todo en el uso del namespace y de endl el cual finaliza la línea de forma muy parecida a como lo hace ‘\n’.

Formato de salida

Podemos dar formato a la salida usando secuencias de escape sin necesidad de usar ninguna librería adicional. Estas secuencias de escape son muy parecias a las de otros lenguajes, por ejemplo \n para el salto de línea o \t para insertar una tabulación,

Puedes incluir la librería iomanip para poder darle un ancho fijo a la salida con la función setw:

#include <iomanip>

std::cout<<"\n\nTexto sin formato\n";
std::cout<<"Roca"<<"Tierra"<<"Volador"<< "\n";
std::cout<<"\nTexto con setw(15)\n";
std::cout<<"Roca"<<std::setw(15)<<"Tierra"<<std::setw(15)<<"Volador"<< "\n";
std::cout<<"\nTexto con tabulaciones\n";
std::cout<<"Roca\t"<<"Tierra\t"<<"Volador"<< "\n";

Que produce:

Texto sin formato
RocaTierraVolador

Texto con setw(15)
Roca         Tierra        Volador


Texto con tabulaciones
Roca    Tierra    Volador

Entrada y salida de archivos

Las operaciones con archivos son algo que suele generar quebraderos de cabeza en los programadores noveles. En C++ es muy importante seguir determinadas pautas si no queremos encontrarnos con programas erróneos o archivos corruptos.

Sigue estos pasos cada vez que vayas a realizar algún tipo de operación con archivos:

 - Incluye la librería <fstream> 
 - Crea un stream (input, output, both)
      - ofstream miarchivo; (para escribir a un archivo)
      - ifstream miarchivo; (para leer un archivo)
      - fstream miarchivo; (para leer y escribir a un archivo)
 - Abre el archivo miarchivo.open("nombre");
 - Escribe o lee el archivo
 - Cierra el archivo miarchivo.close();

Te adjunto un programa de ejemplo que puedes usar como base para el trabajo con archivos:

// incluye la libreria iostream
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main () {
    string line;
    // crea un stream para escritura
    ofstream miArchivo1 ("entrada.txt", ios::app);
    if (miArchivo1.is_open())
    {
        miArchivo1 << "\nAñado una linea.\n";
        miArchivo1 << "Otra línea más.\n";
        miArchivo1.close();
    }
    else cout << "Imposible abrir el archivo para escritura";

    // crea un stream para lectura
    ifstream miArchivo2 ("entrada.txt");
    // crear una variable de tipo ifstream abre el archivo
    if (miArchivo2.is_open())
    {
        while ( getline (miArchivo2, line) )
        {
            cout << line << '\n';
        }
        miArchivo2.close();
    }
    else cout << "Imposible abrir el archivo para lectura";

    return 0;
}