Conceptos Básicos
Bienvenido a C++
C++ es un lenguaje popular multiplataforma que puede utilizarse para crear aplicaciones de
alto rendimiento: sistemas operativos, navegadores, videojuegos, aplicaciones artísticas,
etc.
C++ fue derivado de C, sobre el cual está ampliamente basado.
================================
Bienvenido a C++
Un programa de C++ es una colección de comandos o declaraciones.
A continuación se muestra una sencilla plantilla del programa:
#include <iostream>
using namespace std;
int main()
{
return 0;
}
Aprenderás lo que hace cada una de las declaraciones en las próximas lecciones.
Por ahora, recuerda que el punto de entrada de cada programa de C++ es la función main(),
independientemente de lo que haga el programa.
Los Corchetes { } indican el comienzo y el final de una función, que también puede ser
llamada el cuerpo de la función. La información dentro de los paréntesis indica lo que hace
la función cuando se ejecuta.
================================
Tu primer programa en C++
¡Vamos a generar "Hello world!" en la pantalla!
Para hacerlo, añadiremos la línea cout << "Hello world!"; a nuestro cuerpo de función
main():
#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!";
return 0;
}
cout es el objeto stream utilizado para realizar la salida en el dispositivo de salida estándar
que suele ser la pantalla de visualización.
cout se utiliza en combinación con el operador de inserción <<.
En C++, los streams se utilizan para realizar operaciones de entrada y salida.
================================
Tu primer programa en C++
Puedes añadir múltiples operadores de inserción después de la cita.
{
cout << "This " << "is " <<
"awesome!";
return 0;
}
En C++, el punto y coma se usa para terminar una declaración. Cada declaración debe
terminar con un punto y coma. Indica el final de una expresión lógica.
================================
Encabezados
C++ ofrece varios encabezados, cada uno de los cuales contiene información necesaria
para que los programas funcionen correctamente.
Ya hemos visto el encabezado estándar <iostream> en nuestro primer programa en C++:
#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!";
return 0;
}
#include se utiliza para añadir al programa un archivo de encabezado estándar o definido
por el usuario.
El encabezado <iostream> define los objetos stream estándar que meten y generan datos.
================================
Еspacios de nombres
Un namespace es una región declarativa que proporciona un alcance a los identificadores
(nombres de elementos) dentro de ella.
En nuestro código, la línea using namespace std; le dice al compilador que use el
namespace std (estándar):
#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!";
return 0;
}
El std namespace incluye características de la Biblioteca Estándar de C++.
================================
Nueva línea
El objeto cout no inserta saltos de línea al final de la salida.
Una manera de imprimir dos líneas es utilizar el manipulador endl, el cual colocará un salto
de línea.
#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!" << endl;
cout << "I love programming!";
return 0;
}
Pulsa Ejecutar Este Código para experimentar con el código!
================================
Nuevas líneas
El carácter de nueva línea \n puede utilizarse como una alternativa a endl.
Usando una sola declaración con tantas instancias de /n como tu programa requiera,
imprimirá múltiples líneas de texto.
#include <iostream>
using namespace std;
int main()
{
cout << "Hello world! \n";
cout << "I love programming!\n"<<"I
love c++\n";
return 0;
}
El backslash (\) es un caracter de escape, e indica un caracter "especial"
================================
Comentarios
Los comentarios son declaraciones explicativas que puedes incluir en el código de C++ para
explicar lo que el código está haciendo. El compilador ignorará todo lo que aparezca en el
comentario, por lo que nada de la información aparece en el resultado.
Un comentario que comienza con dos barras inclinadas (//) es conocido como comentario
de una sola línea. Las barras inclinadas le indican al compilador que ignore todo lo demás
que siga, hasta el final de la línea.
#include <iostream>
using namespace std;
int main()
{
// prints "Hello word"
cout << "Hello world!" ;
return 0;
}
Cuando el código anterior es compilado, ignorará la declaración // prints "Hello world".
Añadir comentarios a tu código es una buena práctica. Facilita una clara comprensión del
código para ti y para otros que lo lean.
================================
Comentarios Multi-línea
Los comentarios que requieren múltiples líneas comienzan con /* y terminan con */
Los puedes colocar en la misma línea o insertar una o más líneas entre ellos.
/*we are going to
print "Hello world!" */
cout << "Hello world"; // prints
Hello world!
Los comentarios pueden ser escritos en cualquier parte, y pueden repetirse tantas veces
como sea necesario en el código.
================================
Variables
Al crear una variable reservamos un lugar en la memoria, o un espacio en la memoria para
almacenar valores. El compilador requiere que indiques el tipo de dato para cada variable
que declares.
C++ ofrece una amplia variedad de tipos de datos incorporados por defecto así como
definidos por el usuario.
Los enteros, un tipo de dato incorporado, representan un valor numérico entero. Para definir
un entero utiliza la palabra clave int. C++ requiere que especifiques el tipo y el identificador
para cada variable definida.
Un identificador es un nombre para una variable, función, clase, módulo, o cualquier otra
cosa definida por el usuario. Un identificador comienza con una letra (A-Z o a-z) o un guión
bajo (_), seguido por letras adicionales, guiones bajos, y/o dígitos (0 a 9).
Por ejemplo, define una variable llamada myVariable que pueda almacenar valores enteros
de la siguiente manera:
int myVariable = 10;
Sistemas operativos diferentes pueden reservar diferentes cantidades de memoria para el
mismo tipo de datos.
================================
Variables
Ahora, vamos a asignar un valor a la variable e imprimirla.
#include <iustream>
using namespace std;
int main()
{
int myVariable = 10;
cout << myVariable;
return 0;
}
// Despliega 10
El lenguaje de programación C++ es sensible a mayúsculas, por lo que myVariable y
myvariable son dos identificadores diferentes.
================================
Variables
Define siempre todas las variables con un nombre y un tipo de dato antes de utilizarlas en
un programa. En los casos en que tengas múltiples variables del mismo tipo, es posible
definirlas en la misma declaración, separándolas con comas.
int a, b;
// defines two variables of type int
Se puede asignar un valor a una variable, y puede ser utilizada para realizar operaciones.
Por ejemplo, podemos crear una variable adicional llamada sum, y sumar dos variables.
int a = 30;
int b = 15;
int sum = a + b;
// Now sum equals 45
Utiliza el operador + para sumar dos números.
================================
Variables
Vamos a crear un programa para calcular e imprimir la suma de dos enteros.
#include <iostream>
using namespace std;
int main()
{
int a = 30;
int b = 12;
int sum = a + b;
cout << sum;
return = 0;
}
//Despliega 42
Siempre recuerda que todas las variables deben ser definidas con un nombre y un tipo de
datos antes de que puedan ser utilizadas.
================================
Declarando variables
Tienes la opción de asignar un valor a la variable en el momento que son declaradas o
puedes declararlas y asignarles un valor posteriormente.
También puedes cambiar el valor de una variable.
int a;
int b = 42;
a = 10;
b = 3;
Puedes asignar un valor a una variable sólo en un tipo de datos declarado.
================================
Entrada del usuario
Para permitir al usuario que ingrese un valor, utiliza cin en combinación con el operador
extracción (>>). La variable que almacena la data extraída sigue al operador.
El siguiente ejemplo muestra como recibir la entrada del usuario y almacenarla en la
variable num:
int num;
cin >> num;
Al igual que con cout, las extracciones con cin pueden ser encadenadas para solicitar más
de una entrada en una misma declaración: cin >> a >> b;
================================
Aceptando entradas del usuario
El siguiente programa solicita al usuario que ingrese un número y lo almacena en la variable
a:
#include <iostream>
using namespace std;
int main()
{
int a;
cout << "Please enter a number \n";
con << a;
return 0;
}
Cuando el programa es ejecutado, despliega el mensaje "Please enter a number", y luego
espera a que el usuario ingreso un número y presione la tecla Enter o Retorno.
El número ingresado es almacenado en la variable a.
El programa esperará tanto como sea necesario hasta que el usuario ingrese un número.
================================
Aceptando entradas del usuario
Puedes aceptar múltiples entradas del usuario a través del programa:
#include <iostream>
using namespace std;
int main()
{
int a, b;
cout << "Enter a number \n";
cin << a;
cout << "Enter another number \n";
cin << b;
return 0;
}
Pulsa Ejecutar Este Código para experimentar con el código!
================================
Aceptando entradas de usuario
Vamos a crear un programa que acepte la entrada de dos números e imprima su suma.
#include <iostream>
using namespace std
int main()
{
int a, b;
int suma;
cout << "Enter a number \n";
cin << a;
cout << "Enter another nombre \n";
cin << b;
sum = a, + b;
cout << "sum is: " << sum << endl;
return 0;
}
Pulsa Ejecutar Este Código para experimentar con el código!
================================
Variables
Especificar el tipo de dato se requiere una sola vez, al momento en que la variable sea
declarada.
Después de eso, la variable puede ser utilizada sin referir al tipo de dato.
int a;
a = 10;
Especificar el tipo de dato para una cierta variable más de una vez resulta en un error de
sintaxis.
================================
Variables
El valor de una variable puede ser modificado tantas veces como sea necesario a lo largo
del programa.
int a = 100;
a = 50;
cout << a;
// Despliega 50
Pulsa Ejecutar Este Código para experimentar con el código!
================================
Operadores aritméticos
C++ soporta los siguientes operadores aritméticos.
Operadores Símbolos Formas
Adición + x+y
Substracción - x-y
Multiplicacion * x*y
División / x/y
Módulo % x%y
El operador de adición suma sus operandos.
int x = 40 + 60;
cout << x;
// Despliega 100
Puedes utilizar múltiples operadores aritméticos en una línea.
================================
Substracción
El operador substracción resta un operando del otro.
int x = 100 - 60;
cout << x;
// Despliega 40
Pulsa Ejecutar Este Código para experimentar con el código!
================================
Multiplicación
El operador de multiplicación multiplica sus operandos.
int x = 5 * 6;
cout << x;
// Despliega 30
Pulsa Ejecutar Este Código para experimentar con el código!
================================
División
El operador de división divide el primer operando entre el segundo. Cualquier resto es
ignorado con el fin de devolver un valor entero.
int x = 10 / 3;
cout << x;
// Despliega 3
Si uno o ambos de los operandos son valores de punto flotante, el operador de división
ejecutará una división de punto flotante.
Dividir entre 0 detendrá la ejecución del programa.
================================
Módulo
El operador módulo (%) es conocido informalmente como el operador “resto” porque retorna
el resto después de una división entera.
int x = 25 % 7;
cout << x;
// Despliega 4
Pulsa Ejecutar Este Código para experimentar con el código!
================================
Precedencia de operadores
La precedencia de los operadores determina la agrupación de términos en una expresión, lo
cual afecta como una expresión es evaluada. Algunos operadores tienen mayor
precedencia que otros; por ejemplo, el operador de multiplicación tiene mayor precedencia
sobre el operador de adición.
int x = 5 + 2 * 2;
cout << x;
// Despliega 9
El programa evalúa primero 2*2, y luego suma 5 al resultado.
Tal y como en matemáticas, el uso de paréntesis altera la precedencia de los operadores.
int x = (5 + 2) * 2;
cout << x;
// Despliega 14
Pulsa Ejecutar Este Código para experimentar con el código!
================================
Precedencia de operadores
Los paréntesis obligan las operaciones a tener mayor precedencia. Si hay expresiones entre
paréntesis anidadas unas dentro de otras, la expresión más interna entre los paréntesis es
evaluada primero.
Si ninguna de las expresiones está entre paréntesis, los operadores multiplicativos
(multiplicación, división, módulo) serán evaluados antes que los operadores aditivos
(adición, substracción).
================================
Operadores de asignación
El operador de asignación simple (=) asigna lo que esté del lado derecho al lado izquierdo.
C++ provee operadores reducidos que tienen la capacidad de realizar una operación y una
asignación al mismo tiempo.
int x = 10;
x += 4; // equivalent to x = x + 4
x -= 5; // equivalent to x = x - 5
El operador de asignación simple (=) asigna lo que esté del lado derecho al lado izquierdo.
================================
Operadores de asignación
La misma sintaxis reducida aplica a los operadores de multiplicación, división y módulo.
x *= 3; // equivalent to x = x * 3
x /= 2; // equivalent to x = x / 2
x %= 4; // equivalent to x = x % 4
La misma sintaxis reducida aplica a los operadores de multiplicación, división y módulo.
================================
Operador de incremento
El operador de incremento es utilizado para incrementar el valor de un entero en uno, y es
un operador usualmente usado en C++.
x++; //equivalent to x = x + 1
El operador de incremento es utilizado para incrementar el valor de un entero en uno, y es
un operador usualmente usado en C++.
================================
Operador de incremento
int x = 11;
x++;
cout << x;
// Despliega 12
Pulsa Ejecutar Este Código para experimentar con el código!
================================
Operador de incremento
El operador de incremento tiene dos formas, prefijo y sufijo.
++x; // prefijo
x++; // sufijo
Como prefijo primero se incrementa el valor de la variable, y luego procede a evaluar la
expresión.
Como sufijo, se evalúa la expresión y luego se realiza el incremento en la variable.
Ejemplo de su uso como prefijo
x = 5;
y = ++x;
// x is 6, y is 6
Ejemplo de su uso como sufijo
x = 5;
y = x++;
// x is 6, y is 5
En el ejemplo de prefijo se incrementa el valor de "x", y luego se le asigna a "y".
En el ejemplo de sufijo se asigna el valor de "x" a "y", y luego se incrementa.
================================
Operador de decremento
El operador decremento (--) trabaja de la misma forma que el operador incremento, pero en
lugar de incrementar el valor, lo reduce en uno.
--x; // prefijo
x--; // sufijo
El operador decremento (--) trabaja de la misma forma que el operador incremento.
================================
