Cuando estás trabajando con una colección de variables o de datos en programación, usualmente los guardas en un tipo de dato específico.

En C++, puedes guardarlos en arreglos, estructuras, vectores, cadenas de texto y la lista sigue. Si bien estas estructuras de datos tiene sus características distintivas, en este artículo nos vamos a concentrar en los múltiples métodos para inicializar vectores.

Pero antes, hablemos un poco de los vectores y que los hace destacarse cuando trabajamos con colecciones en C++.

¿Qué son los vectores en C++?

A diferencia de los arreglos, donde la memoria es asignada de forma estática, los vectores nos permiten crear estructuras de datos más dinámicas.

Este es un ejemplo de un arreglo en C++:

#include <iostream>
using namespace std;

int main() {
    string nombres[3] = {"Nicolas", "Matias", "Tomas"};
    cout << nombres[1] << endl;
    // Matias
}
 

El arreglo del código de ejemplo fue creado y reservo en memoria el espacio suficiente para contener solo 3 elementos, en el caso de que quisiéramos agregar nuevos elementos generando un nuevo índice, nos daría como resultado un error.

Con los vectores, las cosas son un poquito diferente, cuando lo definimos, no tenemos que especificar la capacidad que tendrá, tras bambalinas, el espacio en memoria del vector se modifica al mismo tiempo que cambia el tamaño del vector.

Sintaxis de los vectores en C++

Declarar un vector es diferente de inicializarlo, Declararlo significa crear un nuevo vector, mientras que inicializarlo es insertarle elementos en él.

Así es como se ve la sintaxis de un vector:

vector <tipo_de_dato> nombre_de_vector

Cada nuevo vector debe ser declarado usando la palabra clave vector, seguido por el tipo de dato que queremos almacenar encerrado entre paréntesis angulares (el vector puede contener varios tipos de datos: cadenas, enteros, caracteres y la lista sigue), por último debemos especificar el nombre del vector, el cual puede ser cualquiera que nosotros decidamos, aunque siempre es conveniente utilizar nombres que hagan nuestro código lo más legible posible.

Cabe aclarar que debemos escribir la directiva include <vector> al inicio del archivo para poder usar los vectores.

Cómo inicializar un vector en C++

En esta sección, veremos las diferentes maneras de inicializar un vector en C++, las dividiremos en subsecciones con su respectivo ejemplo.

Comencemos con la manera más básica.

Cómo inicializar un vector en C++ usando el método push_back()

push_back() es uno de los varios métodos que podemos usar para interactuar con los vectores. Push_back() toma el parámetro que le demos y lo inserta en el índice final del vector.

Aquí tenemos un ejemplo:

#include <iostream>
#include <vector>
using namespace std;

int main() {
	//declaramos el vector "miVector"
    vector<int> miVector;
	//ahora, inicializamos el vector usando push_back()
	miVector.push_back(5);
	miVector.push_back(10);
	miVector.push_back(15);

	for (int x : miVector)
		cout << x << " ";
		// 5 10 15 
}

En el ejemplo, declaramos el vector, miVector usando la sentencia vector<int> miVector;.

Luego, usando el método push_back() le insertamos tres valores (5,10,15)

Finalmente, usando un bucle for, iteramos en el vector para mostrar en consola los valores.

Como inicializar un vector al mismo tiempo que lo declaramos

Al igual que con los arreglos, podemos asignar valores al vector al momento que lo declaramos.

Veamos el siguiente ejemplo:

#include <iostream>
#include <vector>
using namespace std;

int main() {
	//declaramos e inicializamos el vector miVector
    vector<int> miVector{ 5, 10, 15 };

	for (int x : miVector)
		cout << x << " ";
		// 5 10 15 
}

En este ejemplo, en la misma línea declaramos e inicializamos el vector.

Una vez que los números son asignados al vector, lo recorremos y, posteriormente, los imprimimos en consola.

Habrá notado, que entre paréntesis angulares encerré el tipo de dato que podrá contener el vector, en este caso el tipo es entero int.

Cómo inicializar un vector con un arreglo

Esta vez, inicializaremos el vector con los valores contenidos en un arreglo creado con anterioridad, para esto, utilizaremos dos métodos de la clase vector: begin() y end().

Veamos como es que estos métodos funcionan:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    //Creamos el arreglo que contiene los datos que luego asignaremos al vector
    int miArreglo[] = { 5, 10, 15 };
    //Definimos el vector miVector y, mediante los metodos begin() y end() asignamos el contenido del arreglo que definimos con anterioridad
    vector<int> miVector(begin(miArreglo), end(miArreglo));


	for (int x : miVector)
		cout << x << " ";
		// 5 10 15 
}

Así como utilizamos un arreglo para generar un vector, podemos utilizar los dos métodos vistos en el ejemplo para copiar los valores de un vector hacia otro.

Vectores de tamaño estático: Como inicializar un vector, especificando el tamaño y el valor contenido

Podemos especificar el tamaño y la información que contendrá el vector al momento de declararlo. Esto nos permitirá que el vector tenga un tamaño y un valor específico a través de la ejecución del código.

Aquí te muestro un ejemplo:

#include <iostream>
#include <vector>
using namespace std;

int main() {

  int cantidad_de_elementos = 5; 
  
  vector<int> miVectorFijo(cantidad_de_elementos, 2); 
  
  	for (int x : miVectorFijo)
		cout << x << " ";
// 		2 2 2 2 2 
}

En el ejemplo, primero definimos una variable cantidad_de_elementos = 5, el cual especifica la cantidad de elementos máximos que contendrá el vector.

Luego, declaramos el vector miVectorFijo pasándole 2 parámetros: el primero corresponde al número máximo de elementos que el vector contendrá, mientras que el segundo corresponde al valor que contendrá el vector.

Finalmente, iteramos con un bucle for para poder imprimir en pantalla el contenido del vector, por lo que nos imprimirá 5 veces 2.

Cómo inicializar un vector usando el constructor de una  clase

Podemos inicializar vectores en constructores de clases, de esta forma podemos hacer que la clase sea más dinámica y, no tengamos que programar manualmente los valores del vector al inicializar la clase.

Veamos un ejemplo:

#include <iostream>
#include <vector>
using namespace std;

class Vector {
	vector<int> miVector;

public:
	Vector(vector<int> newVector) {
	    miVector = newVector;
	}
	
	void imprimirVector() {
		for (int i = 0; i < miVector.size(); i++)
			cout << miVector[i] << " ";
	}
	
};

int main() {

    vector <int> vectorNuevo;
    
	vectorNuevo.push_back(5);
	vectorNuevo.push_back(10);
	vectorNuevo.push_back(15);
	
	Vector vector(vectorNuevo);
	vector.imprimirVector();
	// 5 10 15 
}

Vamos a analizar el ejemplo:

class Vector {
	vector<int> miVector;

public:
	Vector(vector<int> newVector) {
	    miVector = newVector;
	}
	
	void imprimirVector() {
		for (int i = 0; i < miVector.size(); i++)
			cout << miVector[i] << " ";
	}
	
};

Primero, creamos la clase Vector, luego creamos una variable de tipo vector a la cual llamamos miVector.

Luego, definimos el constructor de la clase, el cual tiene dos métodos: uno que toma el vector inicializado y otro que imprime en pantalla los valores contenidos en el vector.

int main() {
    vector <int> vectorNuevo;
    
	vectorNuevo.push_back(5);
	vectorNuevo.push_back(10);
	vectorNuevo.push_back(15);
	
	Vector vector(vectorNuevo);
	vector.imprimirVector();
	// 5 10 15 
}

Luego, en el bloque main, creamos un nuevo vector, le insertamos los valores 5,10 y 15.

Finalmente, imprimimos por pantalla el contenido del vector con el método imprimirVector(), el cual fue definido en la clase que creamos anteriormente.

Lo interesante del ejemplo, es que los métodos fueron definidos en la clase, por lo que, no debemos preocuparnos del tamaño del vector (el cual es obtenido por la clase).

Conclusiones

En este artículo, hablamos sobre los vectores en C++, comenzamos diferenciando los arreglos de los vectores (recuerde, que los arreglos tienen un tamaño estático, mientras que los vectores tienen un tamaño dinámico, aunque, en caso de que sea necesario ese tamaño puede ser definido para que también sea estático).

Luego, trabajamos con algunos métodos que podemos utilizar para inicializar el vector y mostramos ejemplos de cada método (nuevamente, recuerde que no es lo mismo declarar que inicializar, declarar es crear en memoria el vector, e inicializar es asignarle valores a ese vector).

¡Que tengas un gran día programando (y aprendiendo)!

En este artículo, hablaremos sobre la función getline() en C++. Esta es una función incorporada que acepta entradas de un solo carácter o múltiples caracteres.

Cuando trabajamos con la entrada del usuario en C++, el objeto cin nos permite obtener información de entrada del usuario. Pero cuando intentamos registrar la entrada del usuario que tiene múltiples valores, solo devuelve el primer carácter.

Esto sucede porque el compilador de C++ asume que cualquier espacio en blanco termina el programa al obtener la entrada. Es decir, "Mi nombre es Ihechikara" solo devolvería "Mi" al registrarse.

Aquí tienes un mejor ejemplo:

#include <iostream>
using namespace std;

int main() {

    string bio;
    
    // Mensaje impreso en la consola
    cout << "Contanos sobre vos: ";
    
    /* Esto le pide al usuario que escriba un mensaje y yo escribí esto: 				"JavaScript es mi lenguaje preferido"
    */
    cin >> bio;
    
    /* Cuando quiero imprimir la bio de arriba, sólo se imprime "Javascript"
    */
    cout << "Tu bio dice: " << bio;
    // Tu bio dice: Javascript

    
}

En el código anterior, se le pide al usuario que ingrese su bio. Luego ingresaron "JavaScript es mi lenguaje preferido". Pero cuando la bio se mostró en la consola, solo se registró "JavaScript".

A continuación, veremos cómo usar la función getline() para obtener el resto de los caracteres en la cadena.

Ejemplo con getline() en C++

En esta sección, veremos un ejemplo práctico de cómo usar la función getline().

#include <iostream>
using namespace std;

int main() {

    string bio;
    
    cout << "Contanos sobre vos: ";
    
    getline(cin, bio);
    
    cout << "Tu bio dice: " << bio;
}

En el ejemplo anterior, pasamos dos parámetros a la función getline(): getline(cin, bio);. El primer parámetro es el objeto cin y el segundo es la variable de cadena bio.

Cuando ejecutas el código, se te pedirá que ingreses algún texto. Después de hacerlo, presiona "Enter" y verás la salida que contiene todo el texto de tu entrada en lugar de solo el primer carácter.

En mi caso, ingresé una cadena con múltiples caracteres y la obtuve registrada en la consola. Inténtalo para ver cómo funciona.

Con esto, puedes trabajar de manera efectiva con las entradas de usuario en tus programas.

Conclusión

En este artículo, hablamos sobre la función getline(), que nos permite obtener múltiples caracteres de la entrada del usuario.

Primero vimos lo que sucede cuando obtenemos una cadena con múltiples caracteres de un usuario: solo se devuelve el primer carácter.

Luego vimos cómo obtener todos los caracteres de la cadena utilizando la función getline(), que toma dos parámetros: el objeto cin y la variable de cadena.

¡Feliz codificación!

En C++, existen varios tipos de datos como string, int, char, bool, float y double. Cada uno de estos tipos de datos tiene valores específicos que se pueden almacenar en ellos.

Cuando trabajamos con números enteros, generalmente los almacenamos en un tipo de dato int. Sin embargo, esto solo es útil para números enteros.

Cuando queremos almacenar números con decimales, podemos usar float o double. Aunque estos dos tipos de datos se utilizan para un propósito similar, tienen algunas diferencias.

En este artículo, hablaremos sobre las diferencias entre float y double en C++ junto con algunos ejemplos.

Diferencia entre Floats y Doubles

Esta sección se dividirá en secciones más pequeñas, cada una enfocada en una diferencia entre float y double.

Diferencia en el tamaño en bytes

El tamaño en bytes para float es 4, mientras que el tamaño en bytes para double es 8. Esto implica que double puede almacenar valores que son el doble de la cantidad que float puede contener. Podemos comprobar esto usando el operador sizeof(). Aquí tienes un ejemplo:

#include <iostream>
using namespace std;
int main() {
    
    cout << "float: " << sizeof(float) << endl; // float: 4
    cout << "double: " << sizeof(double) << endl;// double: 8

}

Diferencia en la precisión (exactitud)

Cuando trabajamos con números que tienen muchas cifras decimales, generalmente esperamos que el valor resultante sea preciso. Sin embargo, la precisión de nuestro resultado depende de la cantidad de cifras decimales con las que estamos tratando. No te preocupes, seguimos hablando de C++, no de matemáticas.

float y double tienen capacidades variables cuando se trata de la cantidad de cifras decimales que pueden contener. float puede mantener hasta 7 cifras decimales de manera precisa, mientras que double puede mantener hasta 15.

Veamos algunos ejemplos para demostrar esto:

#include <iomanip>
#include <iostream>
using namespace std;

int main() {
    double MY_DOUBLE_VALUE = 5.12345678987;

    float MY_FLOAT_VALUE = 5.12345678987;
    
    cout << setprecision(7);
    cout << MY_DOUBLE_VALUE << endl; // 5.123457
    cout << MY_FLOAT_VALUE << endl; // 5.123457
}

En el ejemplo anterior, creamos variables float y double, ambas con el mismo valor: 5.12345678987. La función setprecision() se utiliza para indicar al compilador la cantidad de decimales que deseamos que se impriman. En nuestro caso, el valor es 7.

Podemos observar en los resultados del código anterior que ambas variables imprimieron valores precisos hasta el séptimo lugar decimal: 5.123457.

Ahora aumentemos el parámetro en la función setprecision() a 12 y veamos qué pasa:

#include <iomanip>
#include <iostream>
using namespace std;

int main() {
    double MY_DOUBLE_VALUE = 5.12345678987;

    float MY_FLOAT_VALUE = 5.12345678987;
    
    cout << setprecision(12);
    cout << MY_DOUBLE_VALUE << endl; // 5.12345678987
    cout << MY_FLOAT_VALUE << endl; // 5.12345695496
}

De los resultados anteriores, podemos ver que la variable MY_DOUBLE_VALUE imprimió valores precisos. Sin embargo, la variable MY_FLOAT_VALUE, a partir del séptimo lugar decimal, imprimió valores completamente diferentes al valor original que se le dio. Esto nos muestra la diferencia en la precisión de ambos tipos de datos. Al igual que float, si intentamos devolver un valor que excede el rango de precisión del tipo de dato double, obtendremos un valor inexacto.

Diferencia en el uso

float se utiliza principalmente en bibliotecas gráficas para aplicaciones que requieren un alto poder de procesamiento debido a su rango limitado.
double se utiliza principalmente en cálculos de programación para eliminar errores cuando se redondean valores decimales. Aunque float todavía se puede utilizar, solo debe hacerse en casos en los que se estén manejando valores decimales pequeños. Para estar seguro, siempre se debe utilizar double.

Esta información destaca la importancia de elegir el tipo de dato adecuado según las necesidades de precisión y rango de tus cálculos en C++.

Conclusión

En este artículo, hemos hablado de las diferencias entre float y double en C++. Hemos destacado tres diferencias clave: tamaño en bytes, precisión y casos de uso.

Hemos aprendido que los doubles tienen el doble del tamaño en bytes de los floats y son más precisos al trabajar con valores decimales grandes. Además, hemos explorado los casos de uso que nos ayudan a comprender cuándo utilizar cada tipo de dato.

¡Feliz codificación!

map es un contenedor que almacena elementos en pares clave-valor. Es similar a las colecciones en Java, los arreglos asociativos en PHP, o los objetos en JavaScript.

Aquí están los principales beneficios de usar map:

• map solo almacena claves únicas, y las propias claves están ordenadas
• Debido a que las claves están ya ordenadas, el buscar un elemento es muy rápido
• Hay solo un valor para cada clave

Aquí un ejemplo:

#include <iostream>
#include <map>

using namespace std;

int main (){
  map<char,int> primero;
  
  //inicializando
  primero['a']=10;
  primero['b']=20;
  primero['c']=30;
  primero['d']=40;
  
   map<char, int>::iterator eso;
   for(eso=primero.begin(); eso!=primero.end(); ++eso){
      cout << eso->primero << " => " << eso->segundo << '\n';
   }
   
  return 0;
}

Salida:

a => 10
b => 20
c => 30
d => 40

Creación de un objeto map

map<string, int> miMapa;

Inserción

Inserción de datos con la función miembro insert

miMapa.insert(make_pair("Tierra", 1));
miMapa.insert(make_pair("Luna", 2));

También podemos insertar datos en std::map usando el operador [] es decir

miMapa["Sol"] = 3;

Acceso a los elementos de map

Para acceder a los elementos de map, tienes que crear un iterador. Por ejemplo:

map<char, int>::iterator eso;
for(eso=primero.begin(); eso!=primero.end(); ++eso){
  cout << eso->first << " => " << eso->second << '\n';
}