Capitulo 1 – Lo más básico. Empieza la codificación.

Índice

1.1 Pasos para resolver un problema
1.2 Una aclaración sobre el Pseudocódigo
1.3 Conceptos acerca de la memoria
1.4 Su segundo programa: suma de números enteros
1.5 Un mejor análisis de la asignación de datos
dentro de nuestras 3 variables del Código 1.2

1.1 Pasos para resolver un problema.

Cuando se presenta un problema al que debemos encontrar una solución, debemos siempre analizar una y otra vez, examinando cuidadosamente el problema, para de esta manera obtener una idea clara sobre lo que se solicita y determinar los datos necesarios para conseguir resolverlo. La resolución de un problema podríamos decir que tiene 5 fases:

  1. Análisis del problema: Este es el paso fundamental de toda solución, esta fase consiste en comprender el problema, y un planteamiento correcto nos evitará perder tiempo tiempo = dinero en la implementación del algoritmo. En esta instancia debe quedar claro que datos debemos recibir y que debe salir (lo que el usuario debería ver). Para realizar un buen análisis siempre debemos hacer tres preguntas esenciales:
    • ¿Qué entradas se nos ofrece?
    • ¿Qué salida debemos dar?
    • ¿Cuál es la lógica que debemos utilizar para llegar a la solución deseada?
  2. Diseño del Algoritmo: Si en el análisis determinamos qué debe hacer el programa aquí determinamos cómo lo hace. Es decir, una vez comprendido el problema debemos determinar que pasos o acciones tiene que realizar nuestro programa para resolverlo. Para realizar un buen diseño debemos tener en cuenta que:
    • Si el problema es bastante complejo lo mejor es dividir en partes más pequeñas e intentar resolver los problemas por separado. A esta metodología es a la que llamamos “divide y vencerás”.
    • Las acciones o pasos a realizar tienen que tener un determinado orden.
    • En cada momento solo se puede ejecutar una acción
    • Dentro de las sentencias del algoritmo pueden existir palabras reservadas.
    • Debemos utilizar la indentación (aumenta la legibilidad debido a que facilita la lectura del algoritmo)
  3. Prueba de escritorio: Consiste en que, una vez terminado el algoritmo es necesario hacer un seguimiento manual de los pasos que se definieron en el pseudocódigo y comprobar, si el resultado al cual se llega es el esperado.
  4. Codificación: Es la escritura de las sentencias de nuestro algoritmo en un lenguaje de programación (en nuestro caso C++), en otras palabras es hacer “entender” nuestro algoritmo a la computadora (recuerda que el pseudocódigo es una herramienta que ayuda al programador a estructurar su programa, pero no puede ser entendido por la computadora).
  5. Evaluación de resultados: Una vez hecho los pasos anteriores, es hora de “correr” el programa, es decir ejecutarlo, pero generalmente ocurren errores la vida de un programador no es fácil, o más bien el programa no realiza lo que deseamos, o simplemente no funciona. Podríamos decir que nos podemos llegar a encontrar con dos tipos de errores.
    • Errores de sintaxis: Se producen cuando el programa llega a un punto en el que la computadora no puede realizar la sentencia dada, ya sea por el incumplimiento de la sintaxis de una instrucción.
    • Errores lógicos: Son los más difíciles de detectar, pues se producen por un mal diseño del algoritmo, y por lo tanto, es como el nombre lo indica, la lógica implementada la que falla.

1.2 Una aclaración sobre el Pseudocódigo.

Con el pseudocódigo puedes establecer algunas reglas para estructurar las sentencias del algoritmo, lo bueno de esto es que, sólo se puede cometer errores lógicos, así que puedes empezar a sentirte libre. El formato básico que nosotros utlizaremos será la siguiente

      
    Var
    INICIO
            Cuerpo del programa
    FIN

Este formato se irá ampliando, cuando empecemos a realizar pseudocódigos más complejos. Pasemos por explicar

  1. Var: En esta sección iremos declarando las variables que utilizaremos. [Nota: más adelante iremos hablaremos sobre las variables]
  2. INICIO: Indica el punto en donde el programa empezará a ejecutarse
  3. Cuerpo del programa: Aquí irán las operaciones que nuestro programa realizará
  4. FIN: Indica el final del programa.


[Nota: las palabras que están en mayúsculas serán en cierto sentido nuestras palabras reservadas]

1.3 Su primer programa

Después de tantos párrafos largos y sin sentido prólogos, empezamos a escribir nuestro primer pseudocódigo y  las primeras líneas de código en C++.

He aquí el n-ésimo manual que utiliza el famoso “Hola mundo” (Pseudocódigo 1.1) como primer programa.

En este programa haremos simplemente que imprima una línea de texto con la frase “Hola mundo”. El texto en cursiva que va entre /*  y  */  son comentarios. Los comentarios sirven para ayudar a los programadores a documentar su código, para que al momento de que otro programador o él mismo vuelva a ver el código, comprenda lo que esa fracción de código realiza, o utilizar comentarios como guías de inicio y fin de una sección de código.

    
    /*PS 1.1: ps01_01.txt*/
    /*Programa para mostrar un texto en pantalla*/
    Var
        /*Aquí aún no va nada*/
    INICIO
       Imprimir "Hola Mundo";
       /*Utilizaremos la sentencia "Imprimir"
       para enviar un mensaje que se desplegará
       en la pantalla. Luego de esta sentencia
       ponemos un punto y coma (;) para
       indicar el fin de la sentencia*/
    FIN

Pseudocódigo 1.1| Programa para mostrar un texto en pantalla

Ahora pasaremos este pseudocódigo a C++

C++ es un lenguaje complejo utiliza sentencias o notaciones que pueden parecer extrañas para los que nunca codificaron. Así que iremos explicando línea por línea el programa del Código 1.1

1.  //Cód. 1.1: cod01_01.cpp
2.  //Programa para mostrar un texto en pantalla
3.  #include <iostream>//posibilita que el programa desplace
datos en la pantalla
4.
5.  //la funcion main empieza la ejecucion
6.  int main()
7.  {
8.     std::cout<<"Hola mundo\n Hello World";//despliega un mensaje
en la pantalla
9.
10.    return 0;//indica que el programa no presento errores
11. }//fin de main

Código 1.1| Programa para mostrar un texto en pantalla

Explicación

Este programa por simple y corto que sea, encierra varias características importantes de todo código C++.

Las líneas 1 y 2

    //Cód: 1.1: cod01_01.cpp
    //Programa para imprimir un texto

como se observa, estas líneas al igual que la línea 5 comienzan con //, lo que indica que el resto de la línea es un comentario. El compilador omite (ignora) estas líneas, por lo que los comentarios no son compilados. A estos tipos de comentarios que comienzan con // se les conoce como comentario de una sola línea. (Fíjese que se puede introducir estos comentarios en cualquier parte de una línea, como en las líneas 3 y 8). También existe el comentario de varias líneas, la cual permite escribir varias líneas de comentarios sin necesidad de volver a indicarlo línea por línea, es decir, permite realizar comentarios en bloque, estos tipos de comentarios comienzan con /* y terminan con */.

Utilizaremos los comentarios de una solo línea, estos son la representación de los comentarios /* */ de nuestro pseudocódigo

La línea 3

    #include

es una directiva del preprocesador, la cual es un mensaje para el preprocesador. Todas las líneas que empiecen con el caracter # son procesadas por el preprocesador de C++ antes de compilar el programa. Esta línea en específico indica al preprocesador que incluya el contenido del archivo de encabezado de flujos de entrada/salida <iostream>. Cabe resaltar que si queremos mostrar datos en la pantalla o recibir datos mediante el teclado, debemos incluir este archivo.

En las líneas 4 y 9 se dejan líneas en blanco. Se utilizan líneas en blanco, caracteres de tabulación y caracteres de espacio para facilitar la lectura del código. A estos caracteres se les llama caracteres en blanco. Los compiladores los omiten, pero es muy buena práctica de programación utilizarlos debido a que mejoran la legibilidad del código.

La línea 6

    int main()

es una línea muy especial, esta sentencia está presente en todo programa de C++. Los paréntesis indican que main es una función. Ten en cuenta que: “Todo programa C++ debe tener una sola función main“, main marca el inicio de la ejecución de todo programa en C++, digamos que es la representación de INICIO de nuestro pseudocódigo. La palabra clave int antes de main indica que éste “retorna” un valor entero. En capítulos posteriores veremos que significa “retornar un valor”. Así que mientras tanto solo inclúyelo.

La apertura de llaves (es decir {,  en la línea 7 ) indica el comienzo del cuerpo de toda función (main es una función). Su correspondiente cierre de llaves (es decir }, en la línea 11 ) indica el fin de la función (en este caso main, por lo que también indica el fin de la ejecución del programa, similar al FIN de nuestro pseudocódigo).

La línea 8

    std::cout<<"Hola mundo\n Hello World";

indica que se debe imprimir la cadena que se encuentra entre las comillas dobles. En este caso el compilador no ignora los espacios en blanco que se encuentran contenidos en la cadena.

A la línea 8 completa, (es decir std::cout, el operador <<, la cadena de texto “Hola mundo \n Hello World”, e inclusive el punto y coma ; ) , se le conoce como sentencias. En C++ el uso del punto y coma es obligatorio al final de cada sentencia, excepto en las llamadas al preprocesador (como en la línea 3). C++ realiza la entrada y salida mediante flujos de caracteres. Explicar como hace esto std::cout en esta instancia del curso es muy difícil, así que lo veremos en un capítulo posterior, ahora sólo confórmese con saber que std::cout está enviando el flujo de caracteres “Hola mundo\n Hello World” a la pantalla.

El uso de std:: se requiere cuando utilizamos nombres traídos al programa por una directiva del preprocesador (en este caso, #include <iostream>). El uso de std::cout establece que usaremos un nombre (en este caso, cout) que pertenece al espacio de nombres std. Los espacios de nombres lo veremos con más detalle en próximos capítulos, mientras tanto sólo recuerde incluirlo antes de cada nombre traído por el preprocesador de C++.

El operador de desplazamiento a la izquierda << es el operador de inserción de flujo. Todo valor a la derecha de este operador (el operando derecho), se inserta en el flujo de salida. Los caracteres del operando derecho se muestran igual a como se encuentran entre las comillas dobles. Sin embargo, existen “caracteres especiales”, los cuales van al lado de la barra diagonal inversa (\), a esta barra se la conoce como  carácter de escape, por ejemplo \n no se imprime en pantalla, pero representa una nueva línea. El carácter de escape se combina con el siguiente carácter para formar una secuencia de escape. En la figura 1.1 puede ver una lista de las secuencias de escape.

Actividad 1.1

Cambie la \de la línea 8 con las secuencias de las filas 2 y 3 de la tabla y observe el resultado.

Secuencia de escape Nombre Descripción
\n Nueva línea Indica el final de una línea de texto y el paso a la siguiente
\r Retorno de carro Mueve el cursor a la primera posición de la línea actual
\t Tabulador Desplaza el cursor a la siguiente posición de tabulación
\\ Barra diagonal inversa Imprime un carácter de barra diagonal inversa
\’ Comilla simple Imprime un carácter de comilla sencilla
\” Comilla doble Imprime un carácter de comilla doble

Figura 1.1 | Secuencias de escape

Para terminar esta sección es bueno recordar que el programa del Código 1.1 también puede escribirse de la siguiente manera

1.  #include <iostream>
2.  int main(){std::cout<<"Hola mundo \n Hello World";return 0;}

pero debido a que hacer un código legible facilita el mantenimiento del programa y la corrección de errores utilizamos los espacios en blanco para estructurar el código.

1.3 Conceptos acerca de la memoria

Como dijimos que este curso iba dirigido para Homo sapiens personas que no tenían conocimientos previos de programación, algunos ya experimentados podrían decir que es muy precoz hablar sobre esto, pero nuestra creencia es que los conceptos acerca de la memoria es un tema un poco compleja como para tener que introducirla más adelante, además es un asunto fundamental que todo programador debería conocer.

Para empezar, divagaremos responderemos esta pregunta:

1.3.1 ¿Cómo almacena la información un ordenador?

Básicamente lo hace mediante la utilización de 2 tipos de memoria: la volátil y la no volátil.

La memoria volátil es aquella que, una vez apagado el sistema se vacía (por ejemplo, la RAM sigla de Random Access Memory), aquí nos importa sólo la RAM que es la unidad de almacenamiento. En la RAM se almacenan nuestras variables, que son el objeto de estudio principal de esta sección

En cambio, la memoria no volátil es toda aquella que una vez apagada el sistema o quitado de la fuente de energía, mantiene la información, hasta que alguien decida borrarlos, estos son las unidades de almacenamiento secundario.

A la hora de crear programas, se trabajan con ambos tipos de memoria. Por una parte la memoria volátil es utilizada para almacenar los datos (instrucciones y variables) que se están ejecutando actualmente en la computadora, y por otra parte la memoria no volátil sirve cuando se trabajan con archivos que mantienen por ejemplo configuraciones o datos que no son necesarias para la ejecución, o más bien esos datos no son imprescindibles para “correr” el programa  (eso no quiere decir que no sean importantes para el programa).

En una representación gráfica (análoga, claro está) de una RAM, sería algo como la figura 1.2, pero un equipo puede poseer mayor o menor capacidad de almacenamiento y la cantidad de áreas de memoria es directamente proporcional a la capacidad de almacenamiento, es decir, a mayor cantidad de capacidad de almacenamiento, mayor cantidad de áreas de memoria tendrá el equipo. (Aunque este factor también depende, del tipo de datos que se esté almacenando, esto lo trataremos en otro capitulo).

Áreas de memoria

Figura 1.2 | Áreas de memoria


Cada cuadro representa un área de memoria, que es la que almacena un dato concreto; para que un programa pueda acceder a ese dato, utiliza una dirección, expresada en un valor hexadecimal (en este caso, F4AB34) a esta dirección se la conoce como dirección de memoria, cada área de memoria posee su propia dirección de memoria.

1.3.2 Variables

En una definición técnica podríamos decir que una variable es una zona de memoria referenciada por un nombre de variable, en donde se puede almacenar el valor de un dato, y que ese valor puede modificarse durante la ejecución del programa.

Es importante aclarar que una variable no es un dato, sino un área de memoria que contendrá un dato.

En el transcurso de este y los siguientes capítulos lo entenderá mejor.

Las variables tienen ciertas características, como

Nombre: es el identificador de la variable, es a elección del programador debiendo empezar obligatoriamente por una letra mayúscula o minúscula, no debe contener espacios ni símbolos (excepto el guion bajo “_ “), el resto de los dígitos puede ser números o letras. Recuerde también que debe respetar las palabras reservadas, es decir el nombre de una variable no debe ser igual al de una palabra reservada.

Tipo: corresponde al tipo de datos que almacenará la variable. Si bien existen lenguajes en los cuales no es necesario definir el tipo de variable, C++ si lo requiere. Para C++ la clasificación de los tipos es un poco cuantioso (veremos una lista completa en otro capítulo), para nuestros pseudocódigos sólo tendremos tres opciones, pudiendo ser Numéricos (decimales o enteros), Alfanuméricos (es decir, cadenas de texto) y Booleanos (que lo veremos en otro capítulo).

Lo se, lo entendiste perfectamente… pero igual lo explicaremos de otra manera.

Imagínate un depósito de cajas (cada caja es una variable), en donde cada lugar donde se sitúa una caja (es un área de memoria). Al cabo de unos minutos un empleado se acerca para buscar una caja en especial (la que el programa solicitó) llamada Galletita (el nombre o identificador de la variable)  y lo encuentra (gracias a la dirección de memoria). Pero en este caso el empleado sólo le lleva al cliente (el programa) lo que la caja (la variable) contiene (es decir, el dato), y el cliente (el programa) tiene la opción de modificar el contenido, dejarla igual, el cliente también puede eliminar la caja (la variable).

Pero como esto es una pequeña analogía errónea, no es completamente igual al funcionamiento, en el caso de las variables, los datos (el contenido de la caja) permanecen intactos y en su lugar hasta que el programa decida modificar el contenido, es decir el dato.

1.4 Su segundo programa: suma de números enteros

El siguiente programa obtiene dos números introducidos por el usuario desde el teclado, para realizar el pseudocódigo de este ejemplo seguiremos los pasos de la sección 1.1.

Análisis

Datos de entrada: numero1, numero2
Datos de salida: suma de numero1 y numero2
Proceso:

    Leer el primer numero y asignarlo a numero1
    Leer el segundo numero y asignarlo a numero2
    Sumar numero1 y numero 2
    Imprimir el resultado

Nuestro proceso está completamente en forma literal, lo hacemos así para facilitar la comprensión de lo que queremos realizar, ahora pasaremos esto a pseudocódigo (Pseudocódigo 1.2)

    /*PS 1.2: ps01_02.txt*/
    /*Programa que suma dos números leídos desde el teclado*/
    Var
        /*Las variables utilizadas son del tipo numerico,
        es decir almacenan numeros*/
        Numericos: numero1, numero2, resultado
    INICIO
       /*Utilizaremos la sentencia "Leer"
       para recibir datos introducidos
       por el usuario desde el teclado*/
       Imprimir "Programa para sumar dos números";
       Leer "Ingrese el primer numero: ", numero1;
       Leer "Ingrese el segundo numero: ", numero2;
       resultado = numero1 + numero2;
       Imprimir "El resultado es ", resultado;
    FIN

Pseudocódigo 1.2| Programa que suma dos números leídos desde el teclado

En este ejemplo introducimos cuatros conceptos nuevos: la utilización de variables, el uso de la sentencia Leer , el uso de una operación aritmética y la asignación de valores a una variable.

Como dijimos antes, las variables las declaramos en la sección Var y como queremos recibir y realizar una suma de dos números, por consecuente necesitamos utilizar variables de tipo numérico. Lo declaramos utizando la notación Numéricos: a continuación el nombre de las variables a utilizar separadas por comas.

La sentencia Leer sirve para recibir datos desde el teclado, la sentencia se compone de tres partes fundamentales:

La palabra Leer, seguida de el mensaje (dentro de comillas dobles) que el usuario verá en su pantalla, y la variable que almacenará el valor introducido; el mensaje y la variable se separan por una coma. Es importante mostrar un mensaje apropiado, para que el usuario sepa que es lo que tiene que introducir, tome en cuenta que el usuario no sabe como funciona el programa, y si usted le envía un mensaje como “Introduzca x: “, el usuario no comprenderá lo que está solicitando.

Las operaciones aritméticas funcionan de igual manera que en las matemáticas, suponga que el usuario introduce 5 y 7 como datos de numero1 numero2, respectivamente. El resultado de la suma dará 12 (que grosos somos con las sumas). 

La asignación es el proceso de volcar un valor en una variable, es decir dar un valor a una variable. En el ejemplo la suma de numero1 numero2 es asignado a resultado, es decir el valor de resultado es equivalente a la suma de numero1numero2.

Es importante resaltar que los programas ejecutan las instrucciones (sentencias) de arriba a abajo. En el Pseudocódigo 1.2, la sentencia Imprimir imprime el texto que está contenido entre las comillas dobles, luego se ejecuta la sentencia Leer, la característica de esta sentencia es que mientras el usuario no presione retorno de carro, es decir la tecla Enter, la siguiente sentencia no se ejecutará. En otras palabras Leer espera que el usuario introduzca un dato, de Enter  y luego ejecuta la siguiente secuencia.

Ahora pasaremos este pseudocódigo a C++

Para eso utilizamos el objeto de flujo de entrada std::cin y el operador de desplazamiento a la derecha o de extracción de flujo, >>. Nuevamente no se preocupe aún por saber como funciona std::cin, sólo confórmese que le servirá para recibir datos desde el teclado.

1.   //Cod 1.2: cod01_02.cpp
2.   //Programa que suma dos numeros leidos desde elp
teclado
3.   #include <iostream>
4.   using std::cin;//permite el ingreso de flujo de datos
desde el teclado
5.   using std::cout;//permite la salida de flujo de datos
por pantalla
6.   using std::endl;//permite imprimir un caracter
de nueva linea
7.
8.   int main()
9.   {
10.      int numero1;
11.      int numero2;
12.      int resultado;
13.
14.      cout << "Programa para sumar dos numeros\n";
15.      cout << "Ingrese el primer numero: ";//pide el 
primer numero
16.      cin >> numero1;//lo recibe y lo guarda en numero1
17.      cout << "Ingrese el segundo numero: ";//pide el 
segundo numero
18.      cin >> numero2;//lo recibe y lo guarda en numero2
19.  
20.      //suma los numeros introducidos
21.     resultado = numero1 + numero2;
22.
23.      //imprime el resultado de la suma
24.      cout << "La suma de los numeros introducidos es " 
<< resultado << endl;
25.  }//fin de main

Código 1.2| Programa que suma dos números leídos desde el teclado

Resultado

Salida del Códgio 1.2

Figura 1.2 | Resultado 1.2

En las líneas 4 a 6 se declaran sentencias using, las cuales eliminan la necesidad de escribir el prefijo std:: en todas las utilizaciones de un nombre. Al incluir la sentencia using std::nombre le estamos diciendo al compilador que usaremos un nombre del espacio de nombres std (std significa standard; en español, estándar), en nuestro código anterior: cout, cin y endl, por lo que por ejemplo, en vez de escribir std::cout solo escribiremos cout en cada sentencia en la que queramos utilizarlo.

Las líneas 10 al 12 son declaraciones de variables. Los identificadores numero1, numero2 resultado son nombres de variables. Antes de los identificadores se especifica que estas variables son del tipo int, lo cual indica que estas variables almacenaran números enteros como por ejemplo 15, -48, 1505, 14876, etc. Si las variables son del mismo tipo (como en nuestro ejemplo, las tres variables son del tipo int) pueden declararse también en una sola declaración (valga la redundancia):

int numero1, numero2, resultado;

Los identificadores van separados por comas (,); a esto se lo conoce como lista separada por comas.

Si desea introducir un comentario sobre el uso que se le da a una variable es recomendable que lo declare en un línea separada. Si se va a introducir una lista separada por coma, lo recomendable es introducir un espacio después de la coma; esto permite una mejor lectura de la misma.

De a poco iremos introduciendo los tipos de datos double (para números reales o de punto flotante) y los tipos char (para datos de tipo carácter). Así que quédese con nosotros y no cambie de canal…

Es bueno recordar que C++ (al igual que todos la mayoría de los lenguajes de programación) se rige por las reglas de declaración de variables  (hablando de las reglas para nombrar las variables). También es obligatorio recomendable que nombre a las variables de acuerdo a la tarea que va a realizar, esto facilita la depuración y que a la hora de leer el código, sea más entendible en que variables se van guardando los datos además facilitar el acceso a los datos. Si no nos cree, cuando desarrolles un programa pon nombres de variables que no sean descriptivos y al comienzo del código la dirección de su casa y dele a otro programador para que lo modifique, tendrá suerte si al día siguiente amanece vivo… bueno, esto es en serio un tanto exagerado.

Las declaraciones pueden ser colocadas prácticamente en cualquier parte dentro de un programa, pero eso sí, deben declararse antes de que la variable sea utilizada por primera vez.

  Actividad 1.2

Mueva las declaración de cada variable, justo antes de que sea utilizada por primera vez. Por ejemplo la declaración:

int numero1;

antes de cin >> numero1;

Fíjese que el programa igual funciona.

La línea 15

cout << "Ingrese el primer numero: ";

imprime la cadena “Ingrese el primer numero: “, indicando al usuario que debe realizar una acción específica.

La línea 16

cin >> numero1;

utiliza el objeto de flujo de entrada cin para obtener un valor del teclado. Al usar el operador de extracción de flujo (>>) con cin se obtiene la entrada de caracteres de flujo de entrada estándar, el teclado.

La combinación de las lineas 15 y 16 vendrían a cumplir la misma función que Leer en nuestro pseudocódigo, en donde cout instruye al usuario que debe realizar una acción y cin vuelca (asigna) el dato introducido en una variable. Con cin ocurre lo mismo que describimos sobre Leer, cuando la ejecución llega hasta una instrucción cin

Las líneas 17 y 18 funcionan de la misma manera que las líneas 15 y 16

La sentencia de la línea 21

resultado = numero1 + numero2;

realiza una operación aritmética, la suma de los valores de las variables numero1 y numero2, y asigna el resultado a la variable resultado mediante la utilización del operador de asignación (=). Los operadores + y = son operadores binarios, debido a que utilizan dos operandos para realizar una acción.

En la línea 24

cout << "La suma de los numeros introducidos es " << resultado << endl;

imprime la cadena “La suma de los numeros introducidos es “, seguida del valor contenida en resultado, y luego utiliza endl (perteneciente al espacio de nombres std). El nombre de endl es una abreviación de “end line” (en español “fin de línea”)

Los cálculos también pueden realizarse en las instrucciones de salida, así podríamos eliminar la sentencia de la línea 21 y reemplazar la línea 24 por

cout << "La suma de los numeros introducidos es " << numero1 + numero2 << endl;

con lo que la variable resultado ya no tendría relevancia en el código anterior.

La instrucción de la línea 24 imprime múltiples tipos de valores. En cierto sentido, el operador de inserción de flujo (<<) “oikuaa” “sabe” como ha de imprimir cada tipo de dato. Al uso de mas de un operador de inserción de flujo en una sola sentencia se conoce como insert operations cascading flow en español operaciones de inserción de flujo en cascada, encadenamiento o la más utilizada: concatenamiento.

1.5 Un mejor análisis de la asignación de datos dentro de nuestras 3 variables del Código 1.2.

Cuando se ejecuta la sentencia

cin>> numero1;

los caracteres introducidos por el usuario pasan a ser un entero, el cual se coloca en una ubicación de memoria que el compilador haya asignado al identificador numero1.

Almacenamiento numero1

Figura 1.3 | Almacenamiento de numero1

En la línea 18:

cin >> numero 2;

nuevamente los caracteres introducidos son leídos como entero, y se coloca en la ubicación de memoria que el compilador asignó a numero2

Almacenamiento numero2

Figura 1.4 | Almacenamiento de numero2

Fíjese que los valores de las variables numero1 y numero2 no necesariamente se almacenan en áreas de memoria adyacentes (es decir, la ubicación de memoria de una de ellas no necesariamente es contigua a la otra)
En la línea 21:

resultado = numero1 + numero2;

El compilador obtiene los valores de las variables numero1 y numero2 a través de la dirección en memoria de éstas, realiza la operación aritmética (en este caso, la suma) y el resultado lo almacena en la variable resultado que también posee una dirección de memoria asignada por el compilador.

Almacenamiento resultado

Figura 1.5 | Almacenamiento de resultado

1.6 Diferencia entre endl y ‘\n’

Quizás se haya dado cuenta que el manipulador de flujos endl (que pertenece al espacio de nombres std) al igual que la secuencia de escape \n realizan un salto de línea. En cuanto a lo visual se refiere, las dos notaciones realizan lo mismo, pero funcionalmente no.

La notación endl realiza un salto de línea, pero también induce un flush del stream (recuerde que stream es lo mismo que flujo de datos). Pero…

¿Qué carajos significa esto?

El software de aplicación, el sistema operativo e incluso el hardware hacen buffering, cabe resaltar que no envían los bytes en stream inmediatamente; es decir, acumulan los datos en un buffer hasta que el mismo se llene, momento en el que se efectúa el flush (es decir, la limpieza del buffer de datos… flush en una traducción literal significa “enjuague” en español). Ahora bien

¿Qué es el buffer?

El buffer de datos es la ubicación de la memoria de un dispositivo digital que está reservada para el almacenamiento temporal de datos. Mientras los datos están en el buffer, aguardan para ser procesados. En el buffer se almacenan datos para evitar que el programa o recurso que los requiere, ya sea hardware o software, se quede sin datos durante una transferencia a un medio más permanente de almacenaje o como en nuestro ejemplo la salida en un dispositivo (en nuestro caso, el monitor).

Actividad 1.3

Investigar la diferencia entre Software Aplicativo y Software Base.

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s