Conceptos Fundamentales de C++: Una Guía Práctica

C++ es un lenguaje de programación potente y versátil, esencial en el desarrollo de software moderno. Comprender sus fundamentos es crucial para escribir código eficiente y robusto. A continuación, exploraremos algunos de los conceptos básicos más importantes de C++, incluyendo características introducidas en C++11.

Espacios de Nombres (Namespaces)

Los espacios de nombres en C++ son una herramienta fundamental para organizar el código en unidades lógicas y evitar conflictos de nombres entre identificadores (variables, funciones, clases, etc.) que tienen el mismo nombre pero pertenecen a diferentes contextos. La palabra clave namespace define un ámbito nuevo, encapsulando los elementos que contiene.

Ejemplo práctico:


#include <iostream> // Para std::cout y std::endl
#include <string>   // Para std::string

// Definición de un espacio de nombres para constantes matemáticas
namespace Matematicas
{
   const double PI = 3.1415926535;
   const double E  = 2.7182818284;

   double calcularAreaCirculo(double radio) {
       return PI * radio * radio;
   }
}

// Otro espacio de nombres para utilidades de cadena
namespace CadenasUtil
{
   std::string concatenar(const std::string& s1, const std::string& s2) {
       return s1 + s2;
   }
}

// Ejemplo de conflicto de nombres resuelto por namespaces
int contador = 0; // Variable global

namespace AplicacionA
{
   int contador = 100; // Un contador diferente dentro de AplicacionA
}

namespace AplicacionB
{
   void imprimirContador() {
       std::cout << "Contador global: " << ::contador << std::endl;
       std::cout << "Contador en AplicacionA: " << AplicacionA::contador << std::endl;
       // Si no se especifica, tomaría el 'contador' global o del ámbito actual si existiera.
   }
}


int main() {
   // Acceso a miembros de un espacio de nombres usando el operador de ámbito (::)
   std::cout << "Valor de PI: " << Matematicas::PI << std::endl;
   std::cout << "Área de un círculo con radio 5: " << Matematicas::calcularAreaCirculo(5.0) << std::endl;

   // Uso de una declaración 'using' para un miembro específico
   using Matematicas::E;
   std::cout << "Valor de E: " << E << std::endl; // Ahora podemos usar 'E' directamente

   // Uso de la directiva 'using namespace' para un espacio de nombres completo
   using namespace CadenasUtil;
   std::cout << "Cadenas concatenadas: " << concatenar("Hola", " Mundo") << std::endl;

   // Demostración de resolución de conflictos
   AplicacionB::imprimirContador();

   return 0;
}

Entrada y Salida Estándar

En C++, la entrada y salida estándar se gestionan principalmente a través de objetos de flujo (streams) definidos en la biblioteca <iostream>. Los objetos más comunes son std::cout para la salida a la consola y std::cin para la entrada desde el teclado. El objeto std::endl se utiliza para insertar un salto de línea y vaciar el buffer de salida.

A diferencia de las funciones de E/S de C como printf y scanf, los operadores << (inserción de flujo) y >> (extracción de flujo) de C++ son seguros en cuanto a tipos y pueden manejar automáticamente diferentes tipos de datos, lo que hace el código más limpio y menos propenso a errores de formato.

Ejemplo de I/O básica:


#include <iostream>
#include <string>

int main() {
   std::cout << "--- Demostración de Entrada/Salida en C++ ---" << std::endl;

   int edad;
   std::cout << "Por favor, introduce tu edad: ";
   std::cin >> edad;
   std::cout << "Has introducido: " << edad << " años." << std::endl;

   double altura;
   std::cout << "Introduce tu altura en metros: ";
   std::cin >> altura;
   std::cout << "Tu altura es: " << altura << " metros." << std::endl;

   std::string nombre;
   std::cout << "Introduce tu nombre: ";
   std::cin.ignore(); // Ignorar el salto de línea anterior
   std::getline(std::cin, nombre); // Para leer líneas con espacios
   std::cout << "Hola, " << nombre << "!" << std::endl;

   return 0;
}

Parámetros por Defecto (Default Arguments)

Los parámetros por defecto permiten que una función sea invocada con menos argumentos de los que ha sido declarada. Si se omite un argumento para el cual se ha especificado un valor por defecto, ese valor se utilizará automáticamente. Esto es útil para crear funciones flexibles que puedan comportarse de manera diferente según el número de argumentos proporcionados.

Reglas importantes para los parámetros por defecto:

Deben especificarse de derecha a izquierda. Una vez que un parámetro tiene un valor por defecto, todos los parámetros subsiguientes a su derecha también deben tenerlo.
No pueden aparecer en la declaración y la definición de la función simultáneamente si están en archivos separados (.h y .cpp). Lo más común es declararlos en el prototipo (archivo .h).
El valor por defecto debe ser una constante o una expresión constante.
C no soporta parámetros por defecto.

Ejemplo de parámetros por defecto:


#include <iostream>

// Una función para mostrar un mensaje, con parámetros por defecto
void mostrarMensaje(const std::string& texto = "Mensaje predeterminado", int repeticiones = 1) {
   for (int i = 0; i < repeticiones; ++i) {
       std::cout << texto << std::endl;
   }
}

// Función con un parámetro sin valor por defecto y otros con valor por defecto
void configurarNotificacion(int idUsuario, bool esUrgente = false, int nivelSeveridad = 5) {
   std::cout << "Notificación para usuario " << idUsuario << ":" << std::endl;
   std::cout << "  Urgente: " << (esUrgente ? "Sí" : "No") << std::endl;
   std::cout << "  Severidad: " << nivelSeveridad << std::endl;
}

int main() {
   std::cout << "--- Demostración de Parámetros por Defecto ---" << std::endl;

   // Llamada con todos los parámetros por defecto
   mostrarMensaje();

   // Llamada con un parámetro por defecto sobrescrito
   mostrarMensaje("Hola C++");

   // Llamada con todos los parámetros especificados
   mostrarMensaje("Repetir esto", 3);

   std::cout << std::endl;

   // Demostración de parámetros por defecto parciales
   configurarNotificacion(101); // idUsuario=101, esUrgente=false, nivelSeveridad=5
   std::cout << std::endl;
   configurarNotificacion(202, true); // idUsuario=202, esUrgente=true, nivelSeveridad=5
   std::cout << std::endl;
   configurarNotificacion(303, true, 8); // idUsuario=303, esUrgente=true, nivelSeveridad=8

   return 0;
}

Sobrecarga de Funciones (Functon Overloading)

La sobrecarga de funciones permite definir múltiples funciones con el mismo nombre en el mismo ámbito, siempre que sus listas de parámetros (firma) sean diferentes. La firma de una función se determina por el número, el tipo y el orden de sus parámetros. Esto permite a los programadores usar un nombre de función intuitivo para realizar operaciones similares en diferentes tipos de datos o con diferentes conjuntos de entradas.

Condiciones para la sobrecarga de funciones:

Diferente número de parámetros.
Diferentes tipos de parámetros.
Diferente orden de los tipos de parámetros.

El tipo de retorno de la función no es suficiente para distinguir funciones sobrecargadas.

Ejemplo de sobrecarga de funciones:


#include <iostream>
#include <string>

// Función para sumar dos enteros
int sumar(int a, int b) {
   std::cout << "sumar(int, int) llamado." << std::endl;
   return a + b;
}

// Función para sumar dos dobles (sobrecarga por tipo de parámetro)
double sumar(double a, double b) {
   std::cout << "sumar(double, double) llamado." << std::endl;
   return a + b;
}

// Función para sumar tres enteros (sobrecarga por número de parámetros)
int sumar(int a, int b, int c) {
   std::cout << "sumar(int, int, int) llamado." << std::endl;
   return a + b + c;
}

// Función para mostrar un valor entero
void imprimir(int valor) {
   std::cout << "Imprimiendo entero: " << valor << std::endl;
}

// Función para mostrar un texto (sobrecarga por tipo de parámetro)
void imprimir(const std::string& texto) {
   std::cout << "Imprimiendo cadena: " << texto << std::endl;
}

int main() {
   std::cout << "--- Demostración de Sobrecarga de Funciones ---" << std::endl;

   // Llamadas a la función 'sumar'
   std::cout << "Suma de enteros: " << sumar(5, 3) << std::endl;
   std::cout << "Suma de dobles: " << sumar(10.5, 2.3) << std::endl;
   std::cout << "Suma de tres enteros: " << sumar(1, 2, 3) << std::endl;

   std::cout << std::endl;

   // Llamadas a la función 'imprimir'
   imprimir(42);
   imprimir("¡Esto es una cadena!");

   return 0;
}

El Principio de la Sobrecarga de C++: Decoración de Nombres (Name Mangling)

Cuando un programa C/C++ se compila, pasa por varias etapas: preprocesamiento, compilación, ensamblado y enlazado. En la etapa de compilación, las funciones y variables se convierten en símbolos en el código objeto. Para que el enlazador pueda encontrar la implementación correcta de una función, cada función necesita un nombre único.

En C, las funciones se identifican únicamente por su nombre. Por lo tanto, si intentaras definir dos funciones con el mismo nombre, el compilador C generaría un error de redefinición, ya que no sabría cuál llamar. Esto significa que C no soporta la sobrecarga de funciones.

C++ resuelve este problema mediante un proceso llamado decoración de nombres (o "name mangling"). El compilador C++ (como g++) modifica internamente los nombres de las funciones para incluir información sobre sus parámetros. Por ejemplo, una función void miFuncion(int, double) podría ser decorada como algo similar a _Z8miFuncionid (la representación exacta varía entre compiladores).

Gracias a la decoración de nombres, aunque los programadores escriban el mismo nombre para funciones sobrecargadas, el compilador genera nombres internos únicos para cada una, permitiendo al enlazador resolver las llamadas a función correctamente. Por esta razón, el tipo de retorno de una función no puede diferenciar sobrecargas; la decoración de nombres se basa únicamente en el nombre de la función y su lista de parámetros.

Referencias

Una referencia en C++ es un alias o un nombre alternativo para un objeto existente. Una vez que se inicializa una referencia para vincularla a un objeto, no se puede cambiar para referirse a otro objeto. Las referencias son útiles para pasar argumentos a funciones (paso por referencia) y para devolver valores de funciones sin incurrir en la copia de objetos grandes, lo que mejora la eficiencia.

Características clave de las referencias:

Deben inicializarse al momento de su declaración.
Una vez inicializadas, no pueden ser reasignadas a otro objeto.
No existen referencias nulas.
Las referencias pueden ser const, lo que significa que el objeto al que hacen referencia no puede ser modificado a través de la referencia.

Ejemplo de referencias:


#include <iostream>
#include <string>

// Función que incrementa un valor usando una referencia
void incrementarValor(int& num) {
   num++; // Modifica directamente la variable original
}

// Función que devuelve una referencia a un elemento de un array
int& obtenerElemento(int arr[], int indice) {
   return arr[indice]; // Retorna una referencia al elemento del array
}

int main() {
   std::cout << "--- Demostración de Referencias ---" << std::endl;

   int valorOriginal = 10;
   int& aliasValor = valorOriginal; // aliasValor es una referencia a valorOriginal

   std::cout << "Valor original: " << valorOriginal << std::endl; // Salida: 10
   std::cout << "Alias del valor: " << aliasValor << std::endl;  // Salida: 10

   aliasValor = 20; // Modifica valorOriginal a través del alias
   std::cout << "Valor original después de modificar alias: " << valorOriginal << std::endl; // Salida: 20

   // Referencias constantes
   const int constante = 100;
   const int& refConstante = constante;
   // int& errorRef = constante; // Error: no se puede vincular una referencia no constante a un objeto constante
   const int& refTemporal = 50; // Se puede vincular a un valor literal/temporal
   // refTemporal = 60; // Error: no se puede modificar a través de una referencia constante

   std::cout << "Referencia constante a literal: " << refTemporal << std::endl;

   // Referencias como parámetros de función
   int x = 5;
   std::cout << "Valor de x antes de incrementar: " << x << std::endl;
   incrementarValor(x); // x se pasa por referencia y se modifica
   std::cout << "Valor de x después de incrementar: " << x << std::endl;

   // Referencias como valores de retorno
   int miArray[] = {10, 20, 30, 40};
   std::cout << "Elemento en índice 2 antes: " << miArray[2] << std::endl;
   obtenerElemento(miArray, 2) = 55; // Modifica el elemento del array directamente
   std::cout << "Elemento en índice 2 después: " << miArray[2] << std::endl;

   return 0;
}

Diferencias entre Referencias y Punteros:

Aunque las referencias a menudo se implementan internamente usando punteros, conceptualmente y sintácticamente son muy diferentes. Aquí hay una tabla comparativa:

Característica	Referencias	Punteros
Concepto	Alias para un objeto existente.	Almacena la dirección de memoria de un objeto.
Inicialización	Debe inicializarse al declararse.	Puede declararse sin inicializar (puede ser `nullptr`).
Reasignación	No puede ser reasignada a otro objeto.	Puede apuntar a diferentes objetos durente su vida útil.
Valor nulo	No puede ser nula.	Puede ser `nullptr` (nulo).
Operador `sizeof`	Devuelve el tamaño del tipo al que hace referencia.	Devuelve el tamaño de la dirección (4 u 8 bytes).
Aritmética	No soporta aritmética (`++`, `--`, etc., operan sobre el objeto).	Soporta aritmética (avanza o retrocede la dirección).
Nivel de indirección	No existen referencias a referencias (solo referencias a objetos).	Existen punteros a punteros (doble indirección, etc.).
Acceso a objeto	Acceso directo, el compilador maneja la desreferencia implícita.	Necesita desreferencia explícita con `*` o `->`.
Seguridad	Generalmente más seguras, menos propensas a errores de punteros nulos o colgantes.	Menos seguras, requieren manejo cuidadoso para evitar desreferencias nulas o fugas de memoria.


#include <iostream>

int main() {
   int valor = 100;
   int& refValor = valor; // Referencia a 'valor'
   int* ptrValor = &valor; // Puntero a la dirección de 'valor'

   std::cout << "Dirección de 'valor': " << &valor << std::endl;
   std::cout << "Dirección de 'refValor' (es la misma que 'valor'): " << &refValor << std::endl;
   std::cout << "Dirección almacenada en 'ptrValor': " << ptrValor << std::endl;
   std::cout << "Dirección de 'ptrValor' (el propio puntero): " << &ptrValor << std::endl;

   std::cout << "sizeof(valor): " << sizeof(valor) << " bytes" << std::endl;
   std::cout << "sizeof(refValor): " << sizeof(refValor) << " bytes" << std::endl; // Tamaño del tipo int
   std::cout << "sizeof(ptrValor): " << sizeof(ptrValor) << " bytes" << std::endl; // Tamaño del puntero (ej. 8 bytes en sistemas de 64 bits)

   return 0;
}

Funciones Inline

Una función declarada con la palabra clave inline es una sugerencia al compilador para que realice la expansión de la función en el lugar de la llamada, en lugar de generar una llamada a función tradicional. Esto significa que el código de la función se inserta directamente donde se llama, eliminando la sobrecarga asociada con la creación de un marco de pila (stack frame) y el salto a la dirección de la función.

El objetivo principal de las funciones inline es mejorar el rendimiento para funciones pequeñas y de uso frecuente. Sin embargo, es importante recordar que inline es solo una sugerencia para el compilador; este puede ignorarla si considera que la función es demasiado grande o compleja, o si la inlining no sería beneficiosa.

Una consideración importante es que las funciones inline no suelen tener una dirección de memoria separada, por lo que si se declaran y definen por separado (en .h y .cpp respectivamente), pueden causar errores de enlazado ("undefined reference") si la definición no está disponible en cada unidad de traducción donde se utiliza. Por lo tanto, las funciones inline se definen comúnmente en los archivos de cabecera (.h).

Ejemplo de función inline:


#include <iostream>

// Definición de una función inline sencilla
inline int multiplicar(int a, int b) {
   return a * b;
}

int main() {
   std::cout << "--- Demostración de Funciones Inline ---" << std::endl;

   int resultado = multiplicar(7, 8); // El compilador podría insertar 'return 7 * 8;' aquí
   std::cout << "Resultado de la multiplicación: " << resultado << std::endl;

   int num1 = 12;
   int num2 = 3;
   int otroResultado = multiplicar(num1, num2);
   std::cout << "Otro resultado: " << otroResultado << std::endl;

   return 0;
}

La palabra clave auto (C++11)

A partir de C++11, la palabra clave auto se utiliza para la deducción automática del tipo de una variable. El compilador infiere el tipo de la variable a partir de su inicializador. Esto puede hacer que el código sea más conciso y fácil de leer, especialmente cuando se trabaja con tipos complejos, como iteradores de contenedores o expresiones lambda.

Ventajas de `auto`:

Reduce la verbosidad para tipos complejos.
Ayuda a evitar errores tipográficos y de tipo.
Facilita la refactorización (si el tipo del inicializador cambia, el tipo de la variable auto se actualiza automáticamente).

Ejemplo de uso de `auto`:


#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <typeinfo> // Para typeid

// Función de ejemplo para auto
double obtenerValorPI() {
   return 3.14159;
}

int main() {
   std::cout << "--- Demostración de 'auto' (C++11) ---" << std::endl;

   // Deducción de tipos básicos
   auto numeroEntero = 10;          // int
   auto valorDecimal = 15.5f;       // float
   auto caracterLetra = 'X';        // char
   auto miTexto = "Hola, mundo";    // const char*
   auto pi_val = obtenerValorPI();  // double

   std::cout << "Tipo de numeroEntero: " << typeid(numeroEntero).name() << ", Valor: " << numeroEntero << std::endl;
   std::cout << "Tipo de valorDecimal: " << typeid(valorDecimal).name() << ", Valor: " << valorDecimal << std::endl;
   std::cout << "Tipo de caracterLetra: " << typeid(caracterLetra).name() << ", Valor: " << caracterLetra << std::endl;
   std::cout << "Tipo de miTexto: " << typeid(miTexto).name() << ", Valor: " << miTexto << std::endl;
   std::cout << "Tipo de pi_val: " << typeid(pi_val).name() << ", Valor: " << pi_val << std::endl;

   // Uso de auto con tipos complejos (iteradores)
   std::map<std::string, int> edades = {{"Alice", 30}, {"Bob", 25}};
   // Sin auto: std::map<std::string, int>::iterator it = edades.begin();
   auto it = edades.begin(); // Deduce std::map<std::string, int>::iterator
   std::cout << "Primer elemento del mapa: " << it->first << " = " << it->second << std::endl;

   // auto con punteros y referencias
   int z = 99;
   auto ptrZ = &z;      // Deduce int*
   auto& refZ = z;      // Deduce int&
   auto* ptrZ_explicito = &z; // Equivalente a auto ptrZ = &z;
   
   std::cout << "Tipo de ptrZ: " << typeid(ptrZ).name() << ", Valor: " << *ptrZ << std::endl;
   std::cout << "Tipo de refZ: " << typeid(refZ).name() << ", Valor: " << refZ << std::endl;
   std::cout << "Tipo de ptrZ_explicito: " << typeid(ptrZ_explicito).name() << ", Valor: " << *ptrZ_explicito << std::endl;

   // Restricciones de auto:
   // auto sinInicializar; // Error: 'auto' debe ser inicializado.
   // auto j = 1, k = 2.0; // Error: todos los elementos en una declaración 'auto' múltiple deben ser del mismo tipo.
   // void funcionConAutoParam(auto param) {} // Error: 'auto' no se puede usar como tipo de parámetro de función.
   // auto miArray[] = {1, 2, 3}; // Error: 'auto' no se puede usar directamente para declarar arrays.

   return 0;
}

Bucle for Basado en Rango (C++11)

El bucle for basado en rango, introducido en C++11, proporciona una sintaxis más concisa y legible para iterar sobre todos los elementos de un rango (como arrays, contenedores STL como std::vector o std::list, y otras colecciones). Simplifica el código al eliminar la necesidad de manejar explícitamente iteradores o índices.

Sintaxis genarel:


for (declaracion_de_elemento : rango) {
   // Código a ejecutar para cada elemento
}

La declaracion_de_elemento puede ser por valor (para leer elementos) o por referencia (para leer y/o modificar elementos).

Ejemplo de bucle for basado en rango:


#include <iostream>
#include <vector>
#include <string>

int main() {
   std::cout << "--- Demostración de Bucle for Basado en Rango (C++11) ---" << std::endl;

   // Iteración sobre un array de enteros (por valor)
   int numeros[] = {10, 20, 30, 40, 50};
   std::cout << "Elementos del array (lectura): ";
   for (int num : numeros) {
       std::cout << num << " ";
   }
   std::cout << std::endl;

   // Iteración sobre un vector de cadenas (por referencia para posible modificación, o const reference para lectura eficiente)
   std::vector<std::string> frutas = {"manzana", "banana", "cereza"};
   std::cout << "Frutas originales: ";
   for (const std::string& fruta : frutas) { // Usamos const& para eficiencia y para no modificar
       std::cout << fruta << " ";
   }
   std::cout << std::endl;

   // Modificación de elementos de un array usando una referencia
   std::cout << "Doblando valores del array: ";
   for (int& num : numeros) { // 'num' es una referencia, así que se modifica el elemento original
       num *= 2;
       std::cout << num << " ";
   }
   std::cout << std::endl;

   // Iteración con 'auto' para simplificar la declaración del tipo
   std::cout << "Elementos del array modificados (con auto): ";
   for (auto val : numeros) { // 'val' se deduce como int
       std::cout << val << " ";
   }
   std::cout << std::endl;

   return 0;
}

Puntero Nulo nullptr (C++11)

Antes de C++11, los punteros nulos se representaban comúnmente con la macro NULL (definida como 0 o (void*)0) o directamente con el literal entero 0. Aunque esto funcionaba en muchos casos, podía llevar a ambigüedades, especialmente en la resolución de sobrecargas de funciones.

C++11 introdujo nullptr, un literal de puntero nulo tipado que resuelve estas ambigüedades. nullptr es de tipo std::nullptr_t y se puede convertir implícitamente a cualquier tipo de puntero. Su uso es preferido sobre NULL o 0 para representar un puntero nulo, ya que proporciona una mayor seguridad de tipos y claridad semántica.

Ejemplo de uso de `nullptr`:


#include <iostream>
#include <typeinfo> // Para typeid

// Función sobrecargada que acepta un entero
void procesar(int i) {
   std::cout << "procesar(int) llamado con: " << i << std::endl;
}

// Función sobrecargada que acepta un puntero a entero
void procesar(int* ptr) {
   if (ptr == nullptr) {
       std::cout << "procesar(int*) llamado con un puntero nulo." << std::endl;
   } else {
       std::cout << "procesar(int*) llamado con un puntero a: " << *ptr << std::endl;
   }
}

int main() {
   std::cout << "--- Demostración de nullptr (C++11) ---" << std::endl;

   // Con nullptr, el compilador sabe que queremos la versión del puntero
   procesar(nullptr); // Llama a procesar(int*)

   // Usando 0 o NULL podría generar ambigüedad en algunos casos o llamar a la versión int
   // procesar(0);    // Esto llamaría a procesar(int)
   // procesar(NULL); // Esto podría llamar a procesar(int) o a procesar(int*) dependiendo de la definición de NULL y del compilador.

   int valor = 42;
   int* ptrAValor = &valor;
   procesar(ptrAValor); // Llama a procesar(int*)

   int* punteroVacio = nullptr;
   if (punteroVacio == nullptr) {
       std::cout << "El punteroVacio es nulo." << std::endl;
   }

   std::cout << "Tipo de nullptr: " << typeid(nullptr).name() << std::endl; // Mostrará 'St11nullptr_t' o similar

   return 0;
}

Etiquetas: C++ C++11 namespaces iostream default parameters

Publicado el 8-9 17:22

Friki Work

Conceptos Fundamentales de C++: Una Guía Práctica

Ejemplo práctico:

Ejemplo de I/O básica:

Reglas importantes para los parámetros por defecto:

Ejemplo de parámetros por defecto:

Condiciones para la sobrecarga de funciones:

Ejemplo de sobrecarga de funciones:

Características clave de las referencias:

Ejemplo de referencias:

Diferencias entre Referencias y Punteros:

Ejemplo de función inline:

Ventajas de `auto`:

Ejemplo de uso de `auto`:

Sintaxis genarel:

Ejemplo de bucle for basado en rango:

Ejemplo de uso de `nullptr`:

Etiquetas populares

Friki Work

Conceptos Fundamentales de C++: Una Guía Práctica

Ejemplo práctico:

Ejemplo de I/O básica:

Reglas importantes para los parámetros por defecto:

Ejemplo de parámetros por defecto:

Condiciones para la sobrecarga de funciones:

Ejemplo de sobrecarga de funciones:

Características clave de las referencias:

Ejemplo de referencias:

Diferencias entre Referencias y Punteros:

Ejemplo de función inline:

Ventajas de auto:

Ejemplo de uso de auto:

Sintaxis genarel:

Ejemplo de bucle for basado en rango:

Ejemplo de uso de nullptr:

Etiquetas populares

Ventajas de `auto`:

Ejemplo de uso de `auto`:

Ejemplo de uso de `nullptr`: