REPUBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA EDUCACION

INSTITUTO UNIVERSIDAD POLITECNICA

“SANTIAGO MARIÑO”

EXTENSION MATRIN

PROFESOR: INTEGRANTES:

JOSE NAVARRO CHACON MARITZA CI26.833.929

DIAZ MANUEL CI26.650.515

MATURIN 07-2019
 Secuencia de Escape

En programación, conjunto de caracteres que en el código de programación es interpretado

con algún fin.

Por ejemplo, en lenguaje C la secuencia de escape \n.

La barra invertida \ se denomina carácter de escape, el cual indica que debe interpretarse de
otra manera el carácter que le sigue a la derecha, en este caso n. El compilador interpreta a la
secuencia de escape \n como un salto de línea o nueva línea (un ENTER al final de la cadena).

Existen diferentes secuencias de escape en C:

 \n Nueva línea. Coloca el cursor en el principio de la siguiente línea.

 \t Tabulador horizontal. Mueve el cursor al siguiente tabulador.
 \r Retorno de carro. Coloca el cursor hacia el principio de la línea actual.
 \a Alerta. Suena la beep del sistema.
 \\ Imprime la diagonal invertida. Una sola diagonal sería interpretada como un
carácter de escape.
 \” Imprime la doble comilla. Sin la diagonal invertida, se interpretaría como un inicio o
un fin de una cadena.

Características

Para introducir en el interior de una cadena de caracteres algunos caracteres especiales

imposibles de representar mediante texto, utilizamos lo que comúnmente se
denominan secuencias de escape.
Todas ellas comienzan con una barra invertida (\) seguida de otro carácter. En tiempo de
ejecución, las secuencias de escape se sustituyen por los caracteres adecuados. Estas son las
secuencias de escape aceptadas:

 \a: campana.
 \b: retroceso. Produce el mismo efecto que pulsar la tecla de Retroceso destructivo.
 \c: comilla. Provoca la introducción de una comilla.
 \f: salto de página. Provoca el salto de una página.
 \n: nueva línea. Provoca el salto a la línea siguiente.
 \r: retorno de carro. Provoca el retroceso al comienzo de la línea.
 \t: tabulador. Produce el mismo efecto que pulsar la tecla del Tabulador.
 \v: tabulador Vertical.
 \: barra invertida.

Las secuencias de escape \r y \n pueden ser utilizadas en textos estáticos mixtilíneas (menús,
formularios, etc.) pero debido al carácter multiplataforma de Velneo recomendamos usar
únicamente la secuencia de escape \n ya que así, en función del sistema operativo, se muestre
con la secuencia de escape adecuada: \r\n en Windows, \n en Linux y \r en Mac.
Dado que el carácter \ está reservado para las secuencias de escape de cadenas en las
fórmulas, en el caso de que en alguna fórmula necesitemos usar ese carácter, tendremos que
escribirlo por duplicado. Por ejemplo, si en una fórmula queremos escribir una senda en
formato de Windows, "c:\carpeta\fichero.txt", para que no tome la barra de directorio como
secuencia de escape, en la fórmula escribiremos: "c:\carpeta\fichero.txt".

En las fórmulas de Velneo donde se deban especificar sendas habitualmente se usará el

carácter "/" como separador de directorios ("c:/carpeta/fichero.txt"), ya que Velneo se
encarga de traducirlo al formato adecuado a cada sistema operativo donde ejecutemos el
proceso.

Si se trata de un parámetro de una librería externa o de la ejecución de un comando del

sistema, en este caso en la fórmula debemos componer la senda según los requerimientos del
sistema operativo donde se ejecute.

Clasificación

Los códigos de escape ANSI se utilizan para dar formato a la salida de una terminal de texto y
se basan en un estándar ANSI, ANSI X3.64 (también denominado ECMA-48). Cuando se intenta
representar un código de escape la terminal lo intercepta y actúa en función a ese código,
cambiando el color o moviendo el cursor. Las posibilidades de las secuencias de escape son
muy variadas y se utilizaban para dar formato y cambiar el aspecto de lo que se va a mostrar
por la terminal.

En MS-DOS era necesario instalar ANSI. SYS que permitía actuar ante esos códigos. Todos los
códigos de escape comienzan por los caracteres ESC (carácter ASCII número 27 decimal, 1B
en hexadecimal) seguido del carácter [.

Algunos códigos de escape

Secuencia Acción

Desplaza el cursor hacia arriba n filas. Si el cursor se

encontraba en la parte superior de la pantalla, no tenía
ESC [ n A
ningún efecto. Si no se especificaba n el cursor subía
una fila.

Desplaza el cursor n filas hacia abajo. Al igual que con

el desplazamiento hacia arriba, si el cursor se
ESC [ n B
encontraba en la parte inferior de la pantalla el cursor
no se movía, y si no se especificaba n bajaba una fila.

Mueve el curosr n columnas hacia la derecha. Si el

ESC [ n C
cursor se encuentra en la última columna este
comando no tiene efecto. Si no se especifica n el
 desplazamiento es de una columna.

Mueve el cursor n columnas a la izquierda, salvo que

ESC [ n D se encuentre en la primera columna, en cuyo caso no
tiene efecto. Si n no se especifica toma el valor de 1.

Mueve el cursor a la fila n y columna m. Si n no se

ESC [ n; m f
especifica el cursor se mueve a la primera fila.

Borra parte de la pantalla. Si n vale 0 se borra desde el

cursor hasta el final de la pantalla. En caso de
que n valga 1 se borra hasta el principio de la pantalla
ESC [ n J
desde la posición del cursor. Si n vale 2 se borra toda
la pantalla (y utilizando ANSI. SYS de MS-DOS el
cursor va al principio de la pantalla)

Borra parte de la línea. Si n es cero, desde el cursor al

ESC [ n K final de la línea, en caso de que valga 1 se borra hasta
el principio. Si n vale 2 se borra toda la línea.

ESC
Con este comando se redefine el comportamiento de
[ código; parámetro [; parámetro ]
una tecla.
p

ESC [ s Guarda la posición actual del cursor.

Coloca el cursor en la posición guardada

ESC [ u
anteriormente.

Establece la intensidad, el color del primer plano y el

color de fondo del texto. Más ejemplos de códigos y
ESC [ b ; fg ; bg m
colores en http://softwarelivre.org/terceiro/blog/a-
visual-cheat-sheet-for-ansi-color-codes
 Uso

Una secuencia de escape siempre representa a un carácter del ASCII. Dichos caracteres se pueden
clasificar en:

 Gráficos (se corresponden con los símbolos más usados para escribir por los humanos).
 No gráficos (representan a acciones, como por ejemplo, mover el cursor de la pantalla al
principio de la línea siguiente).

La forma más sencilla de escribir una secuencia de escape es con el carácter barra invertida (\),
seguida de un carácter especial. Por tanto, cuando en la cadena de control de la función printf se
escriba una secuencia de escape, o bien se mostrará un carácter gráfico por pantalla, o bien se
realizará una acción. Por ahora, no es necesario conocer todas las secuencias de escape que
existen en lenguaje C, pero sí, algunas de las más utilizadas:

Figura - Secuencias de enlace más utilizadas en la función printf.

En general, cuando se diseña el algoritmo de un programa, el programador no se preocupa del

lugar exacto de la pantalla en donde van a aparecer los datos de salida del programa, ya que, este
aspecto suele concretarse en la codificación.

En Windows, la pantalla (de la consola) está compuesta por 25 filas (líneas) y 80 columnas, es
decir, en pantalla se pueden visualizar 2000 caracteres a la vez (25*80).

Normalmente, al ejecutar un programa escrito en lenguaje C, el cursor se posiciona (por defecto)

en la primera columna de la primera fila.
 Entrada y Salida

Los dispositivos de entrada y salida son aparatos electrónicos que son conectadas a la
computadora a través de sus ranuras de entrada o salida.

En computación, los dispositivos de entrada y salida son los medios con el cual el usuario se
comunica con el sistema de procesamiento de información como, por ejemplo, las tabletas,
computadoras o celulares inteligentes.

En informática, los dispositivos de entrada y salida son también llamados periféricos, ya que,
no son una parte integral del sistema informático en sí, sino elementos periféricos que se
conectan al sistema mediante sus ranuras de entrada (inputs) o ranuras de salida (outputs).

Flujo

Todos los datos fluyen a través del ordenador desde una entrada hacia una salida. Este flujo de
datos se denomina también stream. Hay un flujo de entrada (input stream) que manda los
datos desde el exterior (normalmente el teclado) del ordenador, y un flujo de salida (output
stream) que dirige los datos hacia los dispositivos de salida (la pantalla o un archivo).

Tipos de Flujo

Un flujo puede tener dos modos: texto y binario.

Un flujo de texto: consiste solamente de caracteres, como los que aparecen en la pantalla. Los
flujos de texto están organizados en líneas, que pueden ser de hasta 255 caracteres de largo y
están terminadas con un carácter de fin de línea o nueva línea (enter).

Un flujo binario: puede manejar cualquier tipo de dato. Los bytes de datos en un flujo binario
no son traducidos o interpretados en ninguna forma, sino que se leen y escriben como bytes.
Se utilizan para hacer transferencias de grandes volúmenes de datos a gran velocidad.

Leer y Escribir un Archivo

Advertencia: una manipulación incorrecta de ficheros puede dar lugar a la pérdida de datos, al
malfuncionamiento de programas o a fallos del sistema operativo del ordenador. Es necesario
disponer de copias de seguridad de toda información que se considere importante.

Guardar datos a un disco o recuperar los datos previamente guardados son procesos
fundamentales en cualquier programa informático. La importancia del almacenamiento de
contenidos es obvia: envío de información a otros usuarios, posponer el trabajo varios días o
semanas sin tener que introducir manualmente los datos de nuevo, acceso a información
almacenada en sistemas remotos, etc. Incluso para desarrollos de software de relativamente
corta longitud resulta relevante la gestión de datos, por ahorrar una cantidad de tiempo
considerable.
Ficheros y bases de datos constituyen un cuerpo de conocimiento de cierta complejidad y
extensión. Por motivos de espacio no vamos a hacer más que una breve introducción.

Podemos pensar en los ficheros o archivos de forma análoga a lo que sería un archivo físico: un
lugar donde hay información almacenada. Ahora bien, eso no nos dice cómo se encuentra esa
información: si está ordenada (alfabéticamente, de mayor a menor, en impresos con campos
predefinidos), si son datos de un tipo o de varios tipos (numéricos, tipo texto, mezcla de tipos
de datos...), si se leen usando alguna clave de interpretación (una partitura no se lee igual que
un texto), etc. Todo esto es relevante y por ello normalmente sabremos qué tipo de datos
contiene el fichero y cómo están ordenados antes de acceder a él. No es lo mismo guardar
"3246" como número tipo int que como cadena de caracteres. Un tipo int ocupa un espacio en
disco, p.ej. 2 bytes y tiene una "clave" para su lectura, mientras que como caracteres cada cifra
ocupa un byte y se lee como si de texto se tratara.

Un asunto a considerar es si la información está contenida en campos de longitud predefinida.

Clase de Entrada y Salida desde Teclado

Se refiere a las operaciones que se producen en el teclado y en la pantalla de la computadora.

En C no hay palabras claves para realizar las acciones de Entrada/Salida, estas se hacen
mediante el uso de las funciones de la biblioteca estándar (stdio.h).Para utilizar las funciones
de E / S debemos incluir en el programa el archivo de cabecera, ejemplo: stdio.h, mediante la
declaratoria:

#include <stdio.h>

Las Funciones de E/S más simples son getchar () que lee un carácter del teclado, espera un
retorno, es decir un enter y el eco aparece. Es decir la tecla presionada.

 putchar (): Imprime un carácter en la pantalla, en la posición actual del cursor.

Algunas variaciones:

 getche (): Aparece el Eco.

 getch (): No aparece el eco, estas instrucciones se encuentran en la biblioteca conio.h.

Bifurcaciones

Las bifurcaciones permiten ejecutar una de entre varias acciones en función del valor de una
expresión lógica o relacional. Se tratan de estructuras muy importantes ya que son las
encargadas de controlar el flujo de ejecución de un programa. Existen dos bifurcaciones
diferentes: if y switch.

 Bifurcación if: Esta estructura permite ejecutar un conjunto de sentencias en función

del valor que tenga la expresión de comparación (se ejecuta si la expresión de
comparación tiene valor true). Tiene la forma siguiente:

If (booleanExpression) {

statements;
}

Las llaves {} sirven para agrupar en un bloque las sentencias que se han de ejecutar, y no son
necesarias si sólo hay una sentencia dentro del if.

 Bifurcación if else: Análoga a la anterior, de la cual es una ampliación. Las sentencias

incluidas en el else se ejecutan en el caso de no cumplirse la expresión de comparación
(false).

If (booleanExpression) {

statements1;

} else {

statements2;

 Bifurcación if elseif else: Permite introducir más de una expresión de comparación. Si

la primera condición no se cumple, se compara la segunda y así sucesivamente. En el
caso de que no se cumpla ninguna de las comparaciones se ejecutan las sentencias
correspondientes al else.

If (booleanExpression1) {

statements1;

} else if (booleanExpression2) {

statements2;

} else if (booleanExpression3) {

statements3;

} Else {

statements4;

 Sentencia switch: Se trata de una alternativa a la bifurcación if elseif else cuando se

compara la misma expresión con distintos valores. Su forma general es la siguiente:

Switch (expression) {

case value1: statements1; break;

case value2: statements2; break;

case value3: statements3; break;

case value4: statements4; break;

case value5: statements5; break;

case value6: statements6; break;

default: statements7;

Bucles

Un bucle se utiliza para realizar un proceso repetidas veces. Se denomina también lazo o loop.
El código incluido entre las llaves {} (opcionales si el proceso repetitivo consta de una sola
línea), se ejecutará mientras se cumpla unas determinadas condiciones. Hay que prestar
especial atención a los bucles infinitos, hecho que ocurre cuando la condición de finalizar el
bucle (booleanExpression) no se llega a cumplir nunca. Se trata de un fallo muy típico, habitual
sobre todo entre programadores poco experimentados.

 Bucle while: Las sentencias statements se ejecutan mientras BooleanExpression Sea

true.

While (booleanExpression) {

statements;

 Bucle for: La forma general del bucle for es la siguiente:

For (initialization; booleanExpression; increment) {

Statements;

Que es equivalente a utilizar while en la siguiente forma,

Initialization;

While (booleanExpression) {

Statements;

Increment;

 Bucle do while: Es similar al bucle while pero con la particularidad de que el control
está al final del bucle (lo que hace que el bucle se ejecute al menos una vez,
independientemente de que la condición se cumpla o no). Una vez ejecutados los
 statements, se evalúa la condición: si resulta true se vuelven a ejecutar las sentencias
incluidas en el bucle, mientras que si la condición se evalúa a false finaliza el bucle.

Este tipo de bucles se utiliza con frecuencia para controlar la satisfacción de una determinada
condición de error o de convergencia.

Do {

Statements

} While (booleanExpression);

Sentencias

 Sentencias break y continue: La sentencia break es válida tanto para las bifurcaciones
como para los bucles. Hace que se salga inmediatamente del bucle o bloque que se
está ejecutando, sin realizar la ejecución del resto de las sentencias.

La sentencia continue se utiliza en los bucles (no en bifurcaciones). Finaliza la iteración “i” que
en ese momento se está ejecutando (no ejecuta el resto de sentencias que hubiera hasta el
final del bucle). Vuelve al comienzo del bucle y comienza la siguiente iteración (i+1).

 Sentencias break y continue con etiquetas: Las etiquetas permiten indicar un lugar
donde continuar la ejecución de un programa después de un break o continue. El único
lugar donde se pueden incluir etiquetas es justo delante de un bloque de código entre
llaves {} (if, switch, do...while, while, for) y sólo se deben utilizar cuando se tiene uno o
más bucles (o bloques) dentro de otro bucle y se desea salir (break) o continuar con la
siguiente interacción (continue) de un bucle que no es el actual.

Por tanto, la sentencia break labelName finaliza el bloque que se encuentre a continuación de
labelName. Por ejemplo, en las sentencias:

BucleI: // etiqueta o label

For (int i = 0, j = 0; i < 100; i++) {

While (true) {

If ((++j) > 5) {break bucleI ;} // Finaliza ambos bucles

Else {break ;} // Finaliza el bucle interior (while)

 Sentencia return: Otra forma de salir de un bucle (y de un método) es utilizar la

sentencia return. A diferencia de continue o break, la sentencia return sale también
del método o función. En el caso de que la función devuelva alguna variable, este valor
se deberá poner a continuación del return (return value;).
 Anidaciones

El anidamiento (llamado nesting en inglés) es la práctica de

incorporar llamadas (calls) a funciones o procedimientos (unas) dentro de otras, mediante la
inclusión de diversos niveles de paréntesis.

Debido a que la potencial acumulación de éstos últimos suele hacer que la edición y la
detección de errores se vuelva un proceso engorroso, los entornos de programación modernos
-así como los programas de planilla de cálculo- resaltan en negrita el par correspondiente a la
posición que está editando el programador o usuario en cada momento. El control
(automático) del balance o equilibrio entre los paréntesis de apertura y de cierre se suele
conocer como brace match checking en inglés.

Naturalmente, para la resolución matemática de estas complejas formulas encadenadas,

las expresiones deben ser evaluadas desde adentro hacia afuera, ya que los resultados de las
más internas sirven, temporalmente, de datos de entrada de las exteriores.

En los lenguajes de programación estructurada, el anidamiento está relacionado a la inclusión

de estructuras de control dentro de otras, usualmente indicado mediante la inclusión de
distintos niveles de sangría (llamada indentation en inglés) dentro del código fuente, como se
muestra en el sencillo código BASIC siguiente:

Function BuscarCodigo (cod as string) as integer

dim linea, ruta as string
dim valor_a_devolver as integer

ruta="C:\Probar.csv"
If FileExists (ruta) then
Open "C:\Probar.csv" for input as #1
do while not EOF(1)
line input #1, linea
if left(línea, 3)=cod then
'Realizar una acción o varias acciones
End if
loop
close #1
BuscarCodigo=valor_a_devolver
End function

Ruptura

Puedes usar Puntos de Ruptura para pausar tu programa en cierta instrucción (línea de
código).
Para añadir un Punto de Ruptura, selecciona primero la línea de código donde quieres parar.
Ahora haz clic en el menú Depurar y luego en Añadir / Quitar Punto de Ruptura (o pulsando
Ctrl+F5). Haciendo clic en la barra en el margen izquierdo del editor a la altura de la línea
tendrá el mismo efecto que los pasos anteriores:

Cuando cargue el depurador, si tu programa ejecuta la línea de código con el Punto de

Ruptura, Dev-C++ te avisará que se ha llegado a la línea cambiándola el color del fondo a azul:

Ahora puedes examinar los datos en tu programa o ejecutar paso a paso tu programa.

Interrupción

En C las interrupciones se manejan de manera distinta, cada una tiene su función, por ejemplo:
Interrupción externa:
#int_EXT
EXT_isr ()
{
…
}
Interrupción por Timer 1:
#int_timer1
timer1_isr ()
{
…
}
El compilador salta a la función de interrupción cuando se detecta una interrupción. Es el
propio compilador el encargado de generar el código para guardar y restaurar el estado del
procesador.
También es el compilador quien borrará la interrupción (el flag). Sin embargo, nuestro
programa es el encargado de llamar a la función ENABLE_INTERRUPT () para activar
previamente la interrupción junto con el señalizador (flag) global de interrupciones.

En cambio la función que sigue a la directiva #INT_GLOBAL reemplaza al distribuidor de

interrupciones del compilador; dicha función toma el control de las interrupciones y el
compilador no salva ningún registro. Normalmente no es necesario usar esto y debe tratarse
con gran prudencia.

La prioridad de las interrupciones se maneja con el siguiente comando:

#priority rtcc, rb

Manejo de excepciones

Primeramente, antes de entrar en el tema de las excepciones en programación, se ha de

matizar en el concepto de qué son las excepciones, vistas desde un punto de vista fuera y
dentro del mundo de la programación.

En el lenguaje humano, una excepción es un elemento excluyente de una regla, y de forma

convencional se ha extendido esta definición. En el lenguaje máquina, una excepción se trata,
de forma general, de algo que no se espera que ocurra, pero que puede ocurrir, similar al
tratamiento de errores, pero de los errores en tiempo de ejecución.

A veces estas excepciones, para una máquina, no son casos que no deberían estar
contemplados, tal y como un programador se lo asigna, sino que pueden ser indicadores para
comprobar que realmente todo está marchando bien o no.

En los programas de ordenador hechos en C existió durante mucho tiempo la costumbre de

usar el comando "goto" (también implementada en C++), pero éste se ha ido eliminando
progresivamente de casi todos y cada uno de los códigos y programas que han ido surgiendo.
El significado de la función 'goto' no forma parte del libro actual, pero se pueden buscar
referencias por internet donde se especifique con más detalle qué es.

Como una de las formas de control de errores más usuales era con goto, se usaron otras
variantes, como las aserciones de código (assertions, en inglés) o, con la llegada de la
programación orientada a objetos, de los comandos try, catch y throw.

Estructura de Almacenamiento

Una estructura es un tipo de dato compuesto que permite almacenar un conjunto de datos de
diferente tipo. Los datos que contiene una estructura pueden ser de tipo simple (caracteres,
números enteros o de coma flotante etc.) o a su vez de tipo compuesto (vectores, estructuras,
listas, etc.).
A cada uno de los datos o elementos almacenados dentro de una estructura se les
denomina miembros
de esa estructura y éstos pertenecerán a un tipo de dato determinado.
La definición de una estructura en C corresponde con la sintaxis siguiente:
 En esta declaración aclararemos que:

Struct: es una palabra reservada de C que indica que los

elementos que vienen agrupados a continuación entre llaves
componen una estructura.

Nombre estructura: identifica el tipo de dato que se describe y del

cual se podrán declarar variables. Se especifica entre corchetes
para indicar su opcionalidad.

miembro1, miembro2: Son los elementos que componen la

estructura de datos, deben ser precedidos por el tipo dato al cual
pertenecen.

Recordemos que una estructura define un tipo de dato, no una variable, lo que significa que
no existe reserva de memoria cuando el compilador está analizando la estructura.
Posteriormente habrá que declarar variables del tipo definido por la estructura para poder
almacenar y manipular datos.

La declaración de variables de un determinado tipo de estructura de datos se puede realizar

de dos modos:

 Primera: Incluir en la propia definición de la estructura aquellas variables que se van a

emplear en el programa. Esta declaración de variables implica que el ámbito en el que
éstas son reconocidas será el mismo que el de la declaración del tipo de dato
estructura. La sintaxis es:

Ejemplo: estructura de una tarjeta bancaria, utilizando esta primera forma:

struct {

long_int num_tarjeta;

char tipo_cuenta;

char nombre [80];

float saldo;

} cliente1, cliente2;

 Segunda: Definir el tipo de dato estructura con un nombre determinado y declarar

posteriormente las variables de ese tipo de dato. Para ello la estructura se identificará
con un nombre de forma obligatoria.
 Arreglo

Los arreglos son estructuras de datos consistentes en un conjunto de datos del mismo tipo. Los
arreglos tienen un tamaño que es la cantidad de objetos del mismo tipo que pueden
almacenar. Los arreglos son entidades estáticas debido a que se declaran de un cierto tamaño
y conservan ´este todo a lo largo de la ejecución del programa en el cual fue declarado.
Decimos arreglo o array indistintamente.

Unidimensionales

Son un conjunto de valores que se relacionan por medio de un nombre en común. También se
puede decir que son datos que se almacenan bajo el mismo nombre y para diferenciarlos se
utiliza un índice.

En el lenguaje C++ un arreglo puede tener varias dimensiones, en esta ocasión hablaremos de
los arreglos unidimensionales (una dimensión).

Arreglos Unidimensionales

Un arreglo unidimensional es una lista de valores guardados bajo el mismo nombre y del
mismo tipo. Cada valor dentro del arreglo se le conoce como elemento del arreglo.

Para declarar un arreglo unidimensional en C++ se utiliza la siguiente línea de código:

tipo_dato identificador [tamaño];

En “tipo de dato” introduciremos que tipo de dato queremos (int, char, float, etc.), luego en
“identificador” introducimos como llamaremos a nuestro arreglo para ubicarlo e identificarlo
de manera rápida. Y entre los corchetes colocaremos el tamaño que le demos a nuestro array.
Quedando de esta manera:

1 int arreglo[3];

Ya que tenemos declarado nuestro arreglo necesitamos declarar cada uno de los elementos
que lo conforman, para esto utilizamos lo siguiente:

1 arreglo[1]=valor;

Iniciamos con el nombre de nuestro arreglo en el apartado que dice arreglo, entre los
corchetes colocaremos que parte del array utilizaremos, en C++ los valores se inician en 0, esto
quiere decir que si nuestro arreglo es de tamaño 3, al hacer nuestro índice hay que tomar el 0
como valor inicial quedando [0], [1] y [2] completando así nuestros 3 valores del tamaño antes
mencionado.

En la parte “valor” asignaremos el valor que le daremos a ese elemento quedando de la

siguiente manera:

1 arreglo[1]=100;
Ejemplo: el siguiente programa carga el arreglo sqrs con los cuadrados de los números del 1 al
10 y luego los visualiza

#include <iostream>
1 using namespace std;
2 int main()

3 { int sqrs[10];// forma un arreglo de tamaño 10

4 int i;

5 for (i=1;i<11;i++) {
6 sqrs[i-1]=i*i;
7 }// Un ciclo for para ir aumentando el número que elevaremos al cuadrado y definir la
8 operación.

9 for (i=0;i<10;i++) {

10 cout<<sqrs[i]<<endl;

11 }//aumento de posición del índice del arreglo.

return 0;

Bidimensional

Una dimensión es usada para representar elementos en una lista o secuencia de valores. En
algunos casos la relación entre elementos del arreglo no puede representarse en forma de
lista. Un arreglo de 2 dimensiones es usado para representar elementos en una tabla con
columnas y filas, se puede acceder a cualquier elemento dentro del arreglo indicando el índice
de la columna y la fila del arreglo.

La siguiente figura muestra un arreglo con 4 filas y 4 columnas. Las filas se acceden integrando
un rango desde 0 hasta el 3 y las columnas con un rango del 0 al 3. Un arreglo bi-dimensional
se declara de la misma manera que un arreglo unidimensional, exceptuando que su tamaño
debe ser declarado.

1 const int NUMFIL=4; //número de filas

3 const int NUMCOL=4; //número de columnas

4

5 Float caja [NUMFIL] [NUMCOL] //arreglo creado con las constantes

anteriores. [NUMFIL]=primera dimensión. [NUMCOL] =segunda dimensión.

Este ejemplo declara caja como un arreglo de 2 dimensiones cuyos elementos son variables del
tipo float. Para acceder a un elemento individual del arreglo debe de especificar 2 expresiones
(una por cada dimensión) ejemplo: caja [0] [2] donde [0] es fila y [2] columna.

Ejemplos de declaración de arreglos bidimensionales en C++

Necesitamos un arreglo que muestre el clima de cada día de año indicando la semana y el día
(un arreglo de 52*7=364)

1 int clima[52][7];

Nuestro arreglo clima consta de 52 filas y 7 columnas partiendo del 0 al 51 y el 0 al 6, cada

espacio de este contiene un valor int. Nuestra intención es que el arreglo guarde los datos de
cada día del año. Si usamos la expresión clima [2] [6], nos dará el clima del día 7 de la tercer
semana.

Procesando arreglos bidimensionales en C++ para dos dimensiones

Procesar los datos de un arreglo de 2 dimensiones generalmente significa acceder al arreglo en

uno o 4 patrones: aleatorio, a través de columna, a través de filas o a través del arreglo entero.
Por ejemplo un usuario ingresa las coordenadas de un mapa a través de un índice en el arreglo
nombre_calle para llegar a la dirección que desea, este proceso es conocido como aleatorio.

Hay veces que necesitamos utilizar una operación en cada elemento de una fila o columna en
el arreglo. Suponiendo en el caso anterior del clima que queremos sacar un promedio de la
temperatura de una semana debemos sumar los valores en la fila semana y dividirlo entre 7,
este caso accede al arreglo a través de las filas, si por el contrario lo que queremos es el
promedio de un día de la semana en específico (ejemplo promedio de todos lunes del año)
debemos sumar los elementos de la columna días y dividirlo entre 52, este caso accede al
arreglo a través de las columnas, un ejemplo más, si queremos sacar el promedio del clima del
año entero debemos acceder a cada elemento del arreglo (en este caso el orden para acceder
a las filas o columnas no tiene relevancia) y dividirlo entre 364, esto accede a todo el arreglo.

Considerando los 4 ejemplos comunes para procesar los arreglos echemos un vistazo a los
siguientes patrones para acceder a ellos.

 Sumar las filas.

 Sumar las columnas.
 Inicializar el arreglo en 0 (o algún valor específico).
 Mostrar el arreglo.

Primero definimos algunas constantes y variables usando identificadores generales como fila y
columna.
 Búsqueda de Arreglos

 Búsqueda Secuencial: Este algoritmo compara uno a uno los elementos del arreglo
hasta recorrerlo por completo indicando si el número buscado existe.

 Búsqueda Binaria: Este algoritmo permite buscar de una manera más eficiente un dato
dentro de un arreglo, para hacer esto se determina el elemento central del arreglo y se
compara con el valor que se está buscando, si coincide termina la búsqueda y en caso
de no ser así se determina si el dato es mayor o menor que el elemento central, de
esta forma se elimina una mitad del arreglo junto con el elemento central para repetir
el proceso hasta encontrarlo o tener solo un elemento en el arreglo. Este algoritmo
compara elementos consecutivos del arreglo uno con respecto del otro, si es mayor o
menor según el tipo de ordenamiento y los cambia de posición. Este proceso se repite
recorriendo todo el arreglo para posicionar un solo dato, por lo que es necesario
repetirlo para los demás datos del arreglo.

Ordenamiento de Arreglos

 Método de Burbuja: Este método consiste en acomodar el vector moviendo el mayor

hasta la última casilla comenzando desde la casilla cero del vector hasta haber
acomodado el número más grande en la última posición, una vez acomodado el más
grande, prosigue a encontrar y acomodar el siguiente más grande comparando de
nuevo los números desde el inicio del vector, y así sigue hasta ordenar todo los
elementos el arreglo. Este algoritmo es muy deficiente ya que al ir comparando las
casillas para buscar el siguiente más grande, éste vuelve a comparar las ya ordenadas.

 QuickSort: El ordenamiento por partición (Quick Sort) se puede definir en una forma
más conveniente como un procedimiento recursivo. Tiene aparentemente la
propiedad de trabajar mejor para elementos de entrada desordenados
completamente, que para elementos semi ordenados. Esta situación es precisamente
la opuesta al ordenamiento de burbuja. Este tipo de algoritmos se basa en la técnica
"divide y vencerás", o sea es más rápido y fácil ordenar dos arreglos o listas de datos
pequeños, que un arreglo o lista grande. Normalmente al inicio de la ordenación se
escoge un elemento aproximadamente en la mitad del arreglo, así al empezar a
ordenar, se debe llegar a que el arreglo este ordenado respecto al punto de división o
la mitad del arreglo. Se podrá garantizar que los elementos a la izquierda de la mitad
son los menores y los elementos a la derecha son los mayores. Los siguientes pasos
son llamados recursivos con el propósito de efectuar la ordenación por partición al
arreglo izquierdo y al arreglo derecho, que se obtienen de la primera fase. El tamaño
de esos arreglos en promedio se reduce a la mitad. Así se continúa hasta que el
tamaño de los arreglos a ordenar es 1, es decir, todos los elementos ya están
ordenados. En promedio para todos los elementos de entrada de tamaño n, el método
hace O(n log n) comparaciones, el cual es relativamente eficiente.

 ShellSort: La idea básica de este método es distribuir el arreglo de manera que se

genere una matriz de valores donde cada elemento es comparado de manera
 adyacente empleando un mecanismo de inserción directa simple, dicho rango que
genera grupos de manera matricial que es reducido gradualmente hasta estabilizarse
en un valor uniforme de 1. En el método de ordenación por inserción directa es
empleado en cada sub grupo de manera que cada elemento se compara para su
ubicación correcta el arreglo con los elementos que se encuentran en su parte
izquierda. Si el elemento a insertar es más pequeño que el grupo de elementos que se
encuentran a su izquierda, será necesario efectuar varias comparaciones antes de su
ubicación. Shell propone que las comparaciones entre elementos se efectúen con
saltos de mayor tamaño, pero con incrementos decrecientes; así, los elementos
quedarán ordenados más rápidamente.

 MergeSort: Este algoritmo consiste básicamente en dividir en partes iguales la lista de

números y luego mezclarlos comparándolos, dejándolos ordenados. Si se piensa en
este algoritmo recursivamente, podemos imaginar que dividirá la lista hasta tener un
elemento en cada lista, luego lo compara con el que está a su lado y según
corresponda, lo sitúa donde corresponde. 1. Si la longitud de la lista es 0 ó 1, entonces
ya está ordenada. En otro caso: 2. Dividir la lista desordenada en dos sublistas de
aproximadamente la mitad del tamaño 3. Ordenar cada sublista recursivamente
aplicando el ordenamiento por mezcla. 4. Mezclar las dos sublistas en una sola lista
ordenada.
 Bibliografía

 http://www.alegsa.com.ar/Dic/secuencia_de_escape.php
 https://doc.velneo.es/secuencias-de-escape-en-cadenas-de-caracteres.html
 https://es.wikipedia.org/wiki/C%C3%B3digo_escape_ANSI
 https://www.significados.com/dispositivos-de-entrada-y-salida/
 http://www.carlospes.com/curso_de_lenguaje_c/01_09_01_03_secuencias_de_escap
e.php
 http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/archivos/flujos.htm
 http://dptocomp.ing.uc.edu.ve/compAvanzada/teoria/UnidadI/FlujosEntradaSalida.ht
m
 https://www.aprenderaprogramar.com/index.php?option=com_content&view=article
&id=935:leer-y-escribir-archivos-o-ficheros-en-c-fopen-fclose-modos-de-acceso-read-
write-y-append-cu00536f&catid=82&Itemid=210
 https://es.scribd.com/doc/54735075/Entradas-y-Salidas-Del-Lenguaje-C
 http://multiprogrammers.activo.mx/t20-estructura-de-control-bucles-y-bifurcaciones
 https://es.wikipedia.org/wiki/Anidamiento_(inform%C3%A1tica)
 http://www.tel.uva.es/personales/josdie/fprog/Sesiones/manualDevCpp/puntos_de_r
uptura.html
 https://www.todopic.com.ar/foros/index.php?topic=25058.0
 https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Excepciones
 http://decsai.ugr.es/~jfv/ed1/c/cdrom/cap7/cap71.htm
 https://www.fing.edu.uy/tecnoinf/mvd/cursos/prinprog/material/teo/prinprog-
teorico07.pdf
 https://blog.michelletorres.mx/arreglos-unidimensionales-en-c/
 https://es.scribd.com/document/282234872/Busqueda-y-Ordenamiento-de-Arreglos