Estructura de un programa

La mejor forma de aprender un lenguaje de programación es escribiendo programas. Normalmente, el primer

programa que escriben los principiantes es un programa llamado "Hello World", que simplemente imprime
"Hello World" en la pantalla de su computadora. Aunque es muy simple, contiene todos los componentes
fundamentales que tienen los programas C ++:
1 // my first program in C++
2 #include <iostream>
3
4 int main() Hello World!
5{
6 std::cout << "Hello World!";
7}
El panel izquierdo de arriba muestra el código C ++ para este programa. El panel derecho muestra el resultado
cuando el programa es ejecutado por una computadora. Los números grises a la izquierda de los paneles son
números de línea para facilitar la discusión de programas y la búsqueda de errores. No forman parte del
programa.
Examinemos este programa línea por línea:
Línea 1: // my first program in C++
Dos signos de barra inclinada indican que el resto de la línea es un comentario insertado por el
programador pero que no tiene ningún efecto sobre el comportamiento del programa. Los programadores
los utilizan para incluir breves explicaciones u observaciones sobre el código o programa. En este caso, es
una breve descripción introductoria del programa.
Línea 2: #include <iostream>
Las líneas que comienzan con un signo de almohadilla ( #) son directivas leídas e interpretadas por lo que
se conoce como preprocesador . Son líneas especiales que se interpretan antes de que comience la
compilación del programa. En este caso, la directiva #include <iostream> indica al preprocesador
que incluya una sección de código C ++ estándar, conocida como encabezado iostream , que permite
realizar operaciones estándar de entrada y salida, como escribir la salida de este programa (Hola
Mundo) a la pantalla.
Línea 3: una línea en blanco.
Las líneas en blanco no tienen ningún efecto en un programa. Simplemente mejoran la legibilidad del
código.
Línea 4: int main ()
Esta línea inicia la declaración de una función. Esencialmente, una función es un grupo de declaraciones
de código a las que se les da un nombre: en este caso, esto le da el nombre "main" al grupo de
declaraciones de código que siguen. La estructura de las funciones es una sucesión de un tipo ( int), un
nombre ( main) y un par de paréntesis ( ()), que opcionalmente incluyen parámetros.
La función nombrada main es una función especial en todos los programas de C ++; es la función
llamada cuando se ejecuta el programa. La ejecución de todos los programas de C ++ comienza con la
función main, independientemente de dónde se encuentre realmente la función dentro del código.
Líneas 5 y 7: {y}
La llave abierta ( {) en la línea 5 indica el comienzo de la función main y la llave de cierre ( }) en la
línea 7 indica su final. Todo lo que hay entre estas llaves es el cuerpo de la función que define lo que
sucede cuando main se llama. Todas las funciones usan llaves para indicar el comienzo y el final de sus
definiciones.
Línea 6: std::cout << "Hello World!";
Esta línea es una declaración de C ++. Una declaración es una expresión que realmente puede producir
algún efecto. Es el meollo de un programa, especificando su comportamiento real. Las instrucciones se
ejecutan en el mismo orden en que aparecen dentro del cuerpo de una función.
 Esta declaración tiene tres partes: En primer lugar, std::cout identifica el standard character output
device (dispositivo estándar de salida, por lo general, se trata de la pantalla del ordenador). En segundo
lugar, el operador de inserción ( <<), que indica que lo que sigue se inserta en std::cout. Finalmente,
una oración entre comillas ("Hello World!"), que es el contenido insertado en la salida estándar.

Observe que la declaración termina con un punto y coma (;). Este carácter marca el final de la
declaración, al igual que el punto finaliza una oración. Todas las declaraciones de C ++ deben terminar
con un carácter de punto y coma. Uno de los errores de sintaxis más comunes en C ++ es olvidar terminar
una declaración con un punto y coma.
No todas las líneas de este programa realizan acciones cuando se ejecuta el código. Hay una línea que contiene
un comentario (que comienza con //). Hay una línea con una directiva para el preprocesador (comenzando con
#). Hay una línea que define una función (en este caso, la función main). Y, finalmente, una línea con
declaraciones terminadas en punto y coma (la inserción en cout), que estaba dentro del bloque delimitado por
las llaves ( { }) de la función main.
El programa ha sido estructurado en diferentes líneas y debidamente sangrado, para que sea más fácil de
entender por las personas que lo lean. Pero C ++ no tiene reglas estrictas sobre la sangría o sobre cómo dividir
instrucciones en diferentes líneas. Por ejemplo, en lugar de
1 int main ()
2{
3 std::cout << " Hello World!";
4}
Podríamos haber escrito:
int main () { std::cout << "Hello World!"; }
todo en una sola línea, y esto habría tenido exactamente el mismo significado que el código anterior.
En C ++, la separación entre declaraciones se especifica con un punto y coma final ( ;), y la separación en
diferentes líneas no importa en absoluto para este propósito. Muchas declaraciones se pueden escribir en una
sola línea o cada declaración puede estar en su propia línea. La división del código en diferentes líneas solo
sirve para hacerlo más legible y esquemático para las personas que pueden leerlo, pero no tiene ningún efecto
sobre el comportamiento real del programa.
Ahora, agreguemos una declaración adicional a nuestro primer programa:
1 // my second program in C++
2 #include <iostream>
3
4 int main ()
Hello World! I'm a C++ program
5{
6 std::cout << "Hello World! ";
7 std::cout << "I'm a C++ program";
8}
En este caso, el programa realizó dos inserciones std::cout en dos declaraciones diferentes. Una vez más,
la separación en diferentes líneas de código simplemente da mayor legibilidad al programa, ya que main
podría haber sido perfectamente válido definido de esta manera:
int main () { std::cout << " Hello World! "; std::cout << " I'm a C++ program "; }
En su lugar, el código fuente también podría haberse dividido en más líneas de código:
1 int main ()
2{
3 std::cout <<
4 "Hello World!";
5 std::cout
6 << "I'm a C++ program";
7}
Y el resultado nuevamente habría sido exactamente el mismo que en los ejemplos anteriores.
Las directivas de preprocesador (aquellas que comienzan por #) están fuera de esta regla general ya que no son
declaraciones. Son líneas leídas y procesadas por el preprocesador antes de que comience la compilación
adecuada. Las directivas del preprocesador deben especificarse en su propia línea y, debido a que no son
declaraciones, no tienen que terminar con un punto y coma ( ;).
Comentarios
Como se señaló anteriormente, los comentarios no afectan el funcionamiento del programa; sin embargo,
proporcionan una herramienta importante para documentar directamente dentro del código fuente lo que hace el
programa y cómo funciona.
C ++ admite dos formas de comentar código:
1 // line comment
2 /* block comment */
El primero de ellos, conocido como comentario de línea , descarta todo desde donde se encuentran el par de
signos de barra ( //) hasta el final de esa misma línea. El segundo, conocido como comentario de bloque ,
descarta todo entre los /*personajes y la primera aparición de los */personajes, con la posibilidad de incluir
múltiples líneas.
Agreguemos comentarios a nuestro segundo programa:
/* my second program in C++
1 with more comments */
2
3 #include <iostream>
4
5 int main ()
Hello World! I'm a C++ program
6{
7 std::cout << "Hello World! "; // prints
8 Hello World!
9 std::cout << "I'm a C++ program"; // prints I'm
10 a C++ program
}
Si los comentarios se incluyen dentro del código fuente de un programa sin usar las combinaciones de
caracteres de comentario //, /*o */, el compilador los toma como si fueran expresiones de C ++, lo más
probable es que haga que la compilación falle con uno o varios mensajes de error.
Usando el espacio de nombres std
Si ha visto código C ++ antes, es posible que haya visto que se está utilizando cout en lugar de std::cout.
Ambos nombran el mismo objeto: el primero usa su nombre no calificado ( cout), mientras que el segundo lo
califica directamente dentro del espacio de nombres std (como std::cout).
cout es parte de la biblioteca estándar, y todos los elementos de la biblioteca estándar de C ++ se declaran
dentro de lo que se llama un espacio de nombres:
using namespace std;
La declaración anterior permite acceder a todos los elementos del espacio de nombres de manera no calificada
(sin el std::prefijo).
Con esto en mente, el último ejemplo se puede reescribir para hacer usos incondicionales de cout como:
1 // my second program in C++
2 #include <iostream>
3 using namespace std;
4
5 int main () Hello World! I'm a C++ program
6{
7 cout << "Hello World! ";
8 cout << "I'm a C++ program";
9}
Ambas formas de acceder a los elementos del espacio de nombres (calificación explícita y uso de
declaraciones) son válidas en C ++ y producen exactamente el mismo comportamiento. Para simplificar y
mejorar la legibilidad, los ejemplos de estos tutoriales utilizarán con más frecuencia este último enfoque con
declaraciones de uso , aunque tenga en cuenta que la calificación explícita es la única forma de garantizar que
nunca se produzcan colisiones de nombres.
Variables y tipos
La utilidad de los programas "Hello World" mostrados en el capítulo anterior es bastante cuestionable. Tuvimos
que escribir varias líneas de código, compilarlas y luego ejecutar el programa resultante, solo para obtener el
resultado de una simple oración escrita en la pantalla. Sin duda, hubiera sido mucho más rápido escribir la
oración de salida nosotros mismos.
Sin embargo, la programación no se limita solo a imprimir textos sencillos en la pantalla. Para ir un poco más
allá y poder escribir programas que realicen tareas útiles que realmente nos ahorren trabajo, es necesario
introducir el concepto de variables.
Imaginemos que les pido que recuerden el número 5, y luego les pido que también memoricen el número 2 al
mismo tiempo. Acaba de almacenar dos valores diferentes en su memoria (5 y 2). Ahora, si le pido que agregue
1 al primer número que dije, debería retener los números 6 (es decir, 5 + 1) y 2 en su memoria. Entonces
podríamos, por ejemplo, restar estos valores y obtener 4 como resultado.
Todo el proceso descrito anteriormente es un símil de lo que puede hacer una computadora con dos variables.
El mismo proceso se puede expresar en C ++ con el siguiente conjunto de declaraciones:
1 a = 5;
2 b = 2;
3 a = a + 1;
4 result = a - b;
Obviamente, este es un ejemplo muy simple, ya que solo hemos usado dos valores enteros pequeños, pero
considere que su computadora puede almacenar millones de números como estos al mismo tiempo y realizar
operaciones matemáticas sofisticadas con ellos.

Ahora podemos definir la variable como una parte de la memoria para almacenar un valor.
Cada variable necesita un nombre que la identifique y la distinga de las demás. Por ejemplo, en el código
anterior, los nombres de las variables eran a, b y result, pero que podrían haber llamado las variables de
cualquier nombre que podríamos han surgido con, siempre y cuando fueran válidos identificadores de C ++.
Identificadores
Un identificador válido es una secuencia de una o más letras, números y/o caracteres de subrayado (_). Los
espacios, los signos de puntuación y los símbolos no pueden formar parte de un identificador. Además, los
identificadores siempre comenzarán con una letra o el carácter de subrayado (_), pero dichos identificadores, en
la mayoría de los casos, se consideran reservados para palabras clave específicas del compilador o
identificadores externos, así como identificadores que contienen dos caracteres de subrayado sucesivos en
cualquier lugar. En ningún caso pueden comenzar con un número.
C ++ utiliza una serie de palabras clave para identificar operaciones y descripciones de datos;por lo tanto, los
identificadores creados por un programador no pueden coincidir con estas palabras clave. Las palabras clave
reservadas estándar que no se pueden utilizar para los identificadores creados por el programador son:
alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break,
case, catch, char, char16_t, char32_t, class, compl, const, constexpr,
const_cast, continue, decltype, default, delete, do, double, dynamic_cast,
else, enum, explicit, export, extern, false, float, for, friend, goto, if,
inline, int, long, mutable, namespace, new, noexcept, not, not_eq,
nullptr, operator, or, or_eq, private, protected, public, register,
reinterpret_cast, return, short, signed, sizeof, static, static_assert,
static_cast, struct, switch, template, this, thread_local, throw, true,
try, typedef, typeid, typename, union, unsigned, using, virtual, void,
volatile, wchar_t, while, xor, xor_eq
Los compiladores específicos también pueden tener palabras clave reservadas específicas adicionales.
Muy importante: el lenguaje C ++ es un lenguaje "sensible a mayúsculas y minúsculas". Eso quiere decir que
un identificador escrito en mayúsculas no es equivalente a otro con el mismo nombre pero escrito en
minúsculas. Así, por ejemplo, la variable RESULT no es lo mismo que la variable result o la variable
Result. Estos son tres identificadores diferentes que identifican tres variables diferentes.
Tipos de datos fundamentales
Los valores de las variables se almacenan en algún lugar de una ubicación no especificada en la memoria de la
computadora como ceros y unos. Nuestro programa no necesita saber la ubicación exacta donde se almacena
una variable;simplemente puede referirse a él por su nombre. Lo que el programa debe tener en cuenta es el tipo
de datos almacenados en la variable. No es lo mismo almacenar un entero simple que almacenar una letra o un
número grande de coma flotante; aunque todos se representan con ceros y unos, no se interpretan de la misma
forma y, en muchos casos, no ocupan la misma cantidad de memoria.
Los tipos de datos fundamentales son tipos básicos implementados directamente por el lenguaje que representan
las unidades de almacenamiento básicas soportadas de forma nativa por la mayoría de los sistemas. Se pueden
clasificar principalmente en:
• Tipos de caracteres: pueden representar un solo carácter, como 'A' o '$'.El tipo más básico es
char, que es un carácter de un byte. También se proporcionan otros tipos para caracteres más amplios.
• Tipos de números enteros: pueden almacenar un valor de número entero, como 7 o 1024. Existen en
una variedad de tamaños y pueden ser signed or unsigned, dependiendo de si admiten valores negativos
o no.
• Tipos de coma flotante: Pueden representar valores reales, como 3.14 o 0.01, con diferentes
niveles de precisión, dependiendo de cuál de los tres tipos de coma flotante se utilice.
• Tipo booleano: el tipo booleano, conocido en C ++ como bool, solo puede representar uno de dos
estados, true o false.
Aquí está la lista completa de tipos fundamentales en C ++:
Grupo Nombres de tipo * Notas sobre tamaño / precisión
char Exactamente un byte de tamaño. Al menos 8
bits.
char16_t No menor que char. Al menos 16 bits.
Tipos de caracteres
char32_t No menor que char16_t. Al menos 32 bits.
wchar_t Puede representar el mayor conjunto de
caracteres admitido.
signed char Mismo tamaño que char. Al menos 8 bits.
signed short int No menor que char. Al menos 16 bits.
Tipos de enteros (con signed int No menor que short. Al menos 16 bits.
signo)
signed long int No menor que int. Al menos 32 bits.
signed long long int No menor que long. Al menos 64 bits.
unsigned char
unsigned short int
Tipos de enteros (sin Unsigned int (del mismo tamaño que sus homólogos signed)
firmar)
unsigned long int
unsigned long long int
float
Tipos de coma flotante double Precisión no menor a float
long double Precisión no menor a double
Tipo booleano bool
Tipo vacío void Sin almacenamiento
Puntero nulo decltype(nullptr)
* Los nombres de ciertos tipos enteros se pueden abreviar sin sus componentes signed e int; solo se
requiere la parte que no esté en cursiva para identificar el tipo, la parte en cursiva es opcional. Dentro de cada
uno de los grupos anteriores, la diferencia entre los tipos es solo su tamaño (es decir, cuánto ocupan en la
memoria): el primer tipo de cada grupo es el más pequeño y el último es el más grande, siendo cada tipo al
menos lo mismo grande como el que le precede en el mismo grupo. Aparte de eso, los tipos de un grupo tienen
las mismas propiedades. Tenga en cuenta en el panel de arriba que, además de signed short int
signed short short int short char(que tiene un tamaño de exactamente un byte), ninguno de los
tipos fundamentales tiene un tamaño estándar especificado (pero un tamaño mínimo, como máximo).Por lo
tanto, el tipo no es necesario (y en muchos casos no lo es) exactamente este tamaño mínimo. Esto no significa
que estos tipos sean de un tamaño indeterminado, sino que no existe un tamaño estándar para todos los
compiladores y máquinas;cada implementación del compilador puede especificar los tamaños para estos tipos
que mejor se adapten a la arquitectura donde se ejecutará el programa. Esta especificación de tamaño bastante
genérica para tipos le da al lenguaje C ++ mucha flexibilidad para adaptarse y funcionar de manera óptima en
todo tipo de plataformas, tanto presentes como futuras.
Los tamaños de letra anteriores se expresan en bits;cuantos más bits tiene un tipo, más valores distintos puede
representar, pero al mismo tiempo, también consume más espacio en la memoria:
Tamaño Valores representables únicos Notas
8 bits 256 = 28
16 bits 65 536 = 216
32 bits 4 294 967 296 = 232(~ 4 mil millones)
64 bits 18 446 744 073 709 551 616 = 264(~ 18 mil millones de mil millones)
Para los tipos enteros, tener valores más representables significa que el rango de valores que pueden representar
es mayor;por ejemplo, un entero sin signo de 16 bits podría representar 65536 valores distintos en el rango de 0
a 65535, mientras que su contraparte con signo podría representar, en la mayoría de los casos, valores entre -
32768 y 32767. Tenga en cuenta que el rango de los valores positivos se reducen aproximadamente a la mitad
en tipos con signo en comparación con los tipos sin signo, debido al hecho de que uno de los 16 bits se usa para
el signo;esta es una diferencia relativamente modesta en el rango, y rara vez justifica el uso de tipos sin signo
basándose únicamente en el rango de valores positivos que pueden representar.
Para los tipos de coma flotante, el tamaño afecta su precisión, al tener más o menos bits para su significativo y
exponente.
Si el tamaño o la precisión del tipo no son una preocupación, entonces char, int y double normalmente
se seleccionan para representar caracteres, números enteros y valores de punto flotante, respectivamente. Los
otros tipos en sus respectivos grupos solo se utilizan en casos muy particulares.
Las propiedades de los tipos fundamentales en un sistema en particular y la implementación del compilador se
pueden obtener utilizando la clase numeric_limits (ver encabezado estándar <limits>).Si por alguna
razón, se necesitan tipos de tamaños específicos, la biblioteca define ciertos alias de tipo de tamaño fijo en el
encabezado <cstdint>.
Los tipos descritos anteriormente (caracteres, enteros, de punto flotante y booleanos) se conocen
colectivamente como tipos aritméticos. Pero existen dos tipos fundamentales adicionales: void que identifica
la falta de tipo; y nullptr, que es un tipo especial de puntero.
C ++ admite una amplia variedad de tipos basados en los tipos fundamentales discutidos anteriormente; estos
otros tipos se conocen como tipos de datos compuestos y son una de las principales fortalezas del lenguaje C +
+.También los veremos con más detalle en capítulos futuros.
Declaración de variables
C ++ es un lenguaje que requiere que cada variable se declare con su tipo antes de su primer uso. Esto informa
al compilador el tamaño a reservar en memoria para la variable y cómo interpretar su valor. La sintaxis para
declarar una nueva variable en C ++ es sencilla: simplemente escribimos el tipo seguido del nombre de la
variable (es decir, su identificador). Por ejemplo:
1 int a;
2 float mynumber;
Estas son dos declaraciones válidas de variables. El primero declara una variable de tipo int con el
identificador a. El segundo declara una variable de tipo float con el identificador mynumber. Una vez
declaradas, las variables a y mynumber pueden usarse dentro del resto de su alcance en el programa.
Si declara más de una variable del mismo tipo, todas se pueden declarar en una sola declaración separando sus
identificadores con comas. Por ejemplo:
int a, b, c;
Esto declara tres variables (a, b y c), todas de tipo int, y tiene exactamente el mismo significado que:
1 int a;
2 int b;
3 int c;
Para ver cómo se ven las declaraciones de variables en acción dentro de un programa, echemos un vistazo al
código C ++ completo del ejemplo sobre su memoria mental propuesto al principio de este capítulo:
1 // operating with variables 4
2
 3 #include <iostream>
4 using namespace std;
5
6 int main ()
7{
8 // declaring variables:
9 int a, b;
10 int result;
11
12 // process:
13 a = 5;
14 b = 2;
15 a = a + 1;
16 result = a - b;
17
18 // print out the result:
19 cout << result;
20
21 // terminate the program:
22 return 0;
23 }
No se preocupe si algo más que las declaraciones de variables en sí le parecen un poco extrañas. La mayor parte
se explicará con más detalle en los próximos capítulos.
Inicialización de variables
Cuando se declaran las variables del ejemplo anterior, tienen un valor indeterminado hasta que se les asigna un
valor por primera vez. Pero es posible que una variable tenga un valor específico desde el momento en que se
declara. A esto se le llama inicialización de la variable.
En C ++, hay tres formas de inicializar variables. Todos son equivalentes y recuerdan la evolución del lenguaje
a lo largo de los años:
El primero, conocido como inicialización tipo c (porque se hereda del lenguaje C), consiste en añadir un signo
igual seguido del valor al que la variable se inicializa:
type identifier = initial_value;
Por ejemplo, para declarar una variable de tipo int llamada x e inicializarlo a un valor de cero desde el
mismo momento en que se declara, podemos escribir:
int x = 0;
Un segundo método, conocido como inicialización del constructor (introducido por el lenguaje C ++), encierra
el valor inicial entre paréntesis (()):
type identifier (initial_value);
Por ejemplo:
int x (0);
Finalmente, un tercer método, conocido como inicialización uniforme, similar al anterior, pero usando llaves
({}) en lugar de paréntesis (esto fue introducido por la revisión del estándar C ++, en 2011):
type identifier {initial_value};
Por ejemplo:
int x {0};
Las tres formas de inicializar variables son válidas y equivalentes en C ++.
1 // initialization of variables 6
2
3 #include <iostream>
4 using namespace std;
5
6 int main ()
7{
8 int a=5; // initial value: 5
9 int b(3); // initial value: 3
10 int c{2}; // initial value: 2
11 int result; // initial value undetermined
12
13 a = a + b;
14 result = a - c;
15 cout << result;
16
17 return 0;
18 }

Tipo de deducción: auto y decltype

Cuando se inicializa una nueva variable, el compilador puede averiguar cuál es el tipo de variable
automáticamente mediante el inicializador. Para ello, basta con utilizar auto como especificador de tipo para
la variable:
1 int foo = 0;
2 auto bar = foo; // the same as: int bar = foo;
Aquí, bar se declara con un tipo auto; e igual a foo,por lo tanto, el tipo de bar es el tipo de valor usado
en la inicialización de foo, que es int.
Las variables que no se inicializan también pueden hacer uso de la deducción de tipo decltype:
1 int foo = 0;
2 decltype(foo) bar; // the same as: int bar;
Aquí, bar se declara que tiene el mismo tipo que foo.
auto y decltype son funciones poderosas que se agregaron recientemente a c. Pero las características de
deducción de tipos que introducen están diseñadas para usarse cuando el tipo no se puede obtener por otros
medios o cuando su uso mejora la legibilidad del código.
Introducción a las cadenas
Los tipos fundamentales representan los tipos más básicos manejados por las máquinas donde se puede ejecutar
el código. Pero una de las mayores fortalezas del lenguaje C ++ es su rico conjunto de tipos compuestos, de los
cuales los tipos fundamentales son meros bloques de construcción.
Un ejemplo de tipo compuesto es la clase string. Las variables de este tipo pueden almacenar secuencias de
caracteres, como palabras u oraciones.¡Una característica muy útil!
Una primera diferencia con los tipos de datos fundamentales es que para declarar y usar objetos (variables) de
este tipo, el programa necesita incluir el encabezado donde se define el tipo dentro de la biblioteca estándar
(encabezado <string>):
1 // my first string
2 #include <iostream>
3 #include <string>
4 using namespace std;
5
6 int main ()
This is a string
7{
8 string mystring;
9 mystring = "This is a string";
10 cout << mystring;
11 return 0;
12 }
Como puede ver en el ejemplo anterior, las cadenas se pueden inicializar con cualquier literal de cadena válido,
al igual que las variables de tipo numérico se pueden inicializar en cualquier literal numérico válido. Al igual
que con los tipos fundamentales, todos los formatos de inicialización son válidos con cadenas:
1 string mystring = "This is a string";
2 string mystring ("This is a string");
3 string mystring {"This is a string"};
Las cadenas también pueden realizar todas las demás operaciones básicas que los tipos de datos fundamentales
pueden, como declararse sin un valor inicial y cambiar su valor durante la ejecución:
1 // my first string This is the initial string content
2 #include <iostream> This is a different string content
3 #include <string>
4 using namespace std;
5
6 int main ()
7{
 string mystring;
8 mystring = "This is the initial string
9 content";
10 cout << mystring << endl;
11 mystring = "This is a different string
12 content";
13 cout << mystring << endl;
14 return 0;
}
Nota: insertar endl (ends the line) imprime un carácter de nueva línea.
La clase string es un tipo compuesto .Como puede ver en el ejemplo anterior, los tipos compuestos se usan
de la misma manera que los tipos fundamentales: se usa la misma sintaxis para declarar variables e
inicializarlas.