Introducción

Primera idea fundamental para un programador: Un ordenador, por si mismo, no tiene

“inteligencia” alguna, si se le ordena hacer algo mal, el resultado será malo.
En realidad solo puede hacer 3 operaciones básicas:
· Sumar, restar, multiplicar, y dividir dos valores numéricos.
· Comparar dos valores numéricos o alfabéticos (<,>,...)
· Almacenar o recuperar información
Es responsabilidad del programador combinar estos tres tipos de operaciones básicas,
para conseguir unos objetivos determinados mediante un PROGRAMA.
Por tanto, se puede definir un PROGRAMA INFORMÁTICO como una solución para
un problema dado y que resulte válida para ser utilizada en un ordenador mediante un
lenguaje de programación.

Fases seguidas para el diseño de un programa

Problema

Análisis

Especificación

Programación

Algoritmo

Codificación

Programa
Análisis: Examen de lo que necesitaremos informáticamente para resolver el problema.
Ordenadores, periféricos, personal informático..., datos, resultados que queremos
conseguir, relación entre datos y resultados,...
Una vez hecho el análisis, tendremos la ESPECIFICACIÓN de nuestro problema, a
partir de la cual podemos afrontar la fase de:
Programación: Se debe abordar la solución al problema aplicando un conjunto de
técnicas que utilizaremos: programación estructurada y diseño descendente. El
resultado de esta fase el ALGORITMO, que es el conjunto de acciones a realizar por el
ordenador para resolver un problema. Para su representación utilizaremos el
PSEUDOCÓDIGO.
Codificación: “Traducción” del algoritmo a un lenguaje informático, con lo que
obtenemos el PROGRAMA.

Pág. 1
Programación estructurada
La programación estructurada utiliza una serie de reglas básicas para el mejor
desarrollo de los programas. Estas normas se basan fundamentalmente en la no
utilización de la instrucción Go To (Ir a) que provoca un programa lleno de
bifurcaciones, difícil de seguir... La programación estructurada se basa en la utilización
de estructuras de programación, estructuras de control (bucles, ...)
Los programas estructurados son más fáciles de corregir y de modificar.
Actualmente todos los lenguajes de alto nivel son estructurados y además están basados
en la programación modular que consiste en dividir el problema en otros más pequeños
para una más fácil resolución del mismo.

Para la resolución de algoritmos utilizaremos dos herramientas básicas:

Pseudocódigo y Ordinogramas. Ambos intentan expresar la resolución de un problema
mediante un método mecanizable informáticamente. Una vez obtenida la resolución del
problema, éste podrá ser implementado en cualquier lenguaje estructurado. Un ejemplo
de pseudocódigo es el siguiente:

Algoritmo SumaRestaProductoDivisión
Entorno
Num1, Num2 Son Entero
Suma, Resta Son Entero
Prod, Divi Son Real
Inicio
Visualizar 'Introducir el primer número'
Leer Num1
Visualizar ' Introducir el segundo número'
Leer Num2
Suma Num1 + Num2
Resta Num1 - Num2
Prod Num1 * Num2
Divi Num1 / Num2
Visualizar 'La suma es: ', Suma
Visualizar 'La resta es: ', Resta
Visualizar 'El producto es: ', Prod
Visualizar 'La división es: ', Divi
FinAlgoritmo

Pág. 2
Tipos de datos en programación estructurada:

En todos los algoritmos, incluso el más sencillo, se manejan datos de diversos

tipos (Algoritmos+Datos=Programas). Por ello veamos una clasificación de los tipos de
datos que se pueden emplear:

Internos: (RAM)

simples:

- Naturales
- Enteros
- Reales
- Booleanos
- Carácter
- Cadenas de caracteres

estructurados:

estáticos:

- Vectores y matrices
- Registros o Tuplas

dinámicos:

- Pilas
- Listas
- Colas
- Arboles

Externos: (elementos de almacenamiento masivo )

Ficheros:

por su forma de acceso:

- Secuenciales
- Aleatorios

por su formato:

- Binarios
- De texto

Pág. 3
Constantes:

Son valores que no cambian a lo largo de un programa. En pseudocódigo los

declararemos en el Entorno en mayúsculas y se les asignará un valor.

Entorno
TIEMPO real con valor 0.5
COLPANT Natural con valor 80
FILPANT Natural con valor 25
MAXVISU Es Natural con valor 30

Mensaje Es Cadena[200-MAXVISU]
Variables:

Las variables sirven para almacenar valores que se usan a lo largo del
programa. Una variable se debe inicializar o su valor inicial será indeterminado. El
nombre que se le dé a la variable debe ser lo más significativo posible para facilitar la
legibilidad del programa.

en pseudocódigo se declararán en el Entorno antes de usarlas

Entorno
Num1, Num2 Son Entero
Suma, Resta Son Entero
Prod, Divi Son Real

Operadores:

Los operadores como su nombre indica realizan una operación con datos de un
tipo determinado, obteniendo un resultado. Por ejemplo la suma es un operador.

Tipos de operadores:

- Aritméticos:

^,** potenciación x^y

- cambio de signo -x
* multiplicación x*y
/ división real x/y
DIV división entera x DIV y
MOD resto división entera x MOD y
+ suma x+y
- resta x-y

- De relación

= igual x=y
<> distinto x<>y
< menor que x<y
> mayor que x>y

Pág. 4
 <= menor o igual que x<=y
>= mayor o igual que x>=y

- Lógicos

O, Y, NO

Tablas de verdad

0Y0=0 0O0=0 NO 1 = 0
0Y1=0 0O1=1 NO 0 = 1
1Y0=0 1O0=1
1Y1=1 1O1=1

- Alfanuméricos

Nombre+Apellidos

Expresiones:

Una expresión utiliza variables y constantes y realiza operaciones con los

operadores existentes para obtener un resultado. La expresión ha de ser consistente, p.e.
no se pueden multiplicar cadenas de caracteres.

Ejemplo:

Sol1 (-Coef1 + Raíz((Coef1 ^ 2) - 4 * Coef2 * Coef0)) / (2 * Coef2)

En la anterior expresión se utilizan las variables Sol1, Coef0, Coef1, Coef2, la

función Raíz, los operadores *, /, ^ y el símbolo de asignación <-- para calcular una de
las soluciones de una ecuación de 2º grado.

Sentencias de E/S básicas:

Para realizar algoritmos se necesitan algunas sentencias básicas de E/S (por teclado y
pantalla). En pseudocódigo utilizaremos estas. Al programar el algoritmo en un lenguaje
concreto utilizaremos las características propias del mismo para mejorar los detalles.

En pantalla:
Visualizar expresión
BorrarPantalla
PosicionarCursor(fila,columna)

En impresora:
Imprimir expresión

Del teclado:
Leer variable
EsperarTecla

Pág. 5
Sentencias de control estructuradas:
Las sentencias de control ofrecen la posibilidad de controlar la ejecución del
programa.

Secuencial: (Un camino único)

orden_1
orden_2
...
orden_n

Alternativas: (múltiples caminos)

V
Simple
Si expresión lógica Entonces ? secuencia
secuencia de ordenes
FinSi

Doble

Si expresión Entonces
Secuencia1 de ordenes F V
SiNo
Secuencia2 de ordenes
FinSi Secuencia1
Secuencia2

Múltiple
EnCasoDe expresión
En otro caso
Sea rango_1 Hacer Rango1
Secuencia1 de ordenes
Rango-n
Sea rango_2 Hacer
Secuencia2 de ordenes Sec1 Sec2 Sec3
Sec
... SecN
Sea rango_n Hacer
SecuenciaN de ordenes
EnOtroCaso
Secuencia de ordenes
FinEnCasoDe

Pág. 6
 Falso

Repetitivas: (bucles)

Mientras condición Hacer

Secuencia de ordenes Secuencia
FinMientras

Repetir Secuencia
Secuencia de ordenes
HastaQue condición

Falso
Verdadero

Vc  Vi

Verdadero
Vc>Vf
Para Vc  Vi Hasta Vf con incremento incr Hacer
Secuencia de ordenes
FinPara Falso

Secuencia

VcVc +incr

¿ Qué diferencias encuentras entre los tres tipos de estructura iterativa ?

Pág. 7
Funciones predefinidas:

Aunque el usuario puede definir cuantas funciones quiera, los lenguajes de

programación ofrecen una serie de funciones predefinidas básicas.

Trigonométricas:

Sen(x) - Seno, el parámetro en radianes

Cos(x) - Coseno, el parámetro en radianes
Tan(x) - Tangente, el parámetro en radianes
Asn(x) - Arco del seno
Acs(x) - Arco del coseno
Atn(x) - Arco de la tangente

Numéricas:

Abs(x) - Valor absoluto de un número

Red(x) - Redondeo
Ent(x) - Parte entera de un número
Log(x) - Logaritmo en base 10
Ln(x) - Logaritmo Neperiano
Exp(x) - e^x
Raíz(x) - Raíz cuadrada
Random(x) - Número aleatorio

De cadena:

Asc(x) - El código ASCII

ConvCadNum(s) - Convertir Cadena a Número
ConvNumCad(x) - Convertir Número a Cadena
Car(n) - El carácter asociado al cod. ASCII
Lon(s) - Longitud de la cadena
Sub(s,i,n) - Subcadena de longitud n empezando en i
Cad(c,n) - Repetir el carácter
Mayus(c) - Mayúsculas
Minus(c) - Minúsculas

Interruptores, Contadores, Acumuladores:

Hay unos tipos de variables que por su uso se pueden clasificar en tres
grupos muy importantes en programación:

Interruptores: Son variables de tipo lógico o booleano, que deben tener

un nombre muy significativo e indican si ha ocurrido o no algún suceso.

por ejemplo

Entorno
SePulsoTecla es Booleano /* indica si se pulso la tecla */

Pág. 8
 Contadores: Son variables de tipo entero que van incrementando su
valor en una cantidad fija cada vez que ocurre un cierto suceso. Normalmente se utilizan
en bucles.

por ejemplo

Entorno
Cuenta es Entero
Inicio

...
Cuenta <-- Cuenta+1
...

Acumuladores: Son variables que van acumulando valores variables.

p.e. para calcular la suma de varios números

Entorno
Suma es Entero
Numero es entero
Inicio

...
Suma <-- Suma + Numero
...

Tipo de dato Carácter:

Ver páginas [13 .. 16] de los apuntes Introducción al concepto de datos de Oscar Ortiz.

Cadenas de caracteres:

Pág. 9
Array, vector, tabla o matriz.
Un array es un conjunto de posiciones contiguas en la memoria que continen elementos
del mismo tipo y que se referencia por un nombre común.
Los arrays pueden tener de una a varias dimensiones.

Pág. 10
Todo array se compone de un determinado nº de elementos. Cada elemento es referen-
ciado por la posición que ocupa dentro del array. A dichas posiciones se les llama índi-
ce.
Arrays unidimensionales:
La forma general de declaración de un array unidimensional es:
especificador_de_tipo nombre_variable[tamaño];
donde especificador_de_tipo es el tipo base, es decir, el tipo de cada elemento y tamaño
es el número de elementos del array.
por ejemplo:
int puntos[12];
estamos declarando un array unidimensional de 12 elementos de tipo entero.
La forma general de acceder a un elemento del array es:
nombre_variable [indice]
En C++ todas los arrays tienen el cero como índice de su primer elemento. Por tanto,
cuando se escribe por ejemplo int v[10];
se está declarando un array de 10 elementos de tipo entero y el
array va de v[0] a v[9].

C++ no comprueba los límites de los arrays. Esto quiere decir que si hacemos v[20]
para el array anterior, el C no nos va a informar de ningún error. Es responsabilidad del
programador el indexamiento correcto de un array.

Un uso común de los arrays unidimensionales en C es como cadena de caracteres.

En C++ una cadena se define como un array de caracteres que termina en un carácter
nulo. Por ejemplo char nombre[25];

Arrays bidimensionales:
Un array bidimensional es, en realidad, un array unidimensional donde
cada elemento es otro array unidimensional.
Así como a los arrays unidimensionales se les suele llamar vectores, a los arrays bidi-
mensionales se les suele llamar matrices.
La forma general de declaración es:
especificador_de_tipo nombre_variable [tamaño_1] [tamaño_2];
y se accede a los elementos del array:
nombre_variable [indice_1] [indice_2]
Por ejemplo:
Char meses[12][25];

Ejemplo de array bidimensional:

Int main (void)
{

Pág. 11
#include <stdio.h>
#define num_filas 4
#define num_columnas 7
int i, j, matriz [num_filas] [num_columnas];
for (i = 0; i < num_filas; i++)
for (j = 0; j < num_columnas; j++)
matriz[i][j] = i + j;
for (i = 0; i < num_filas; i++)
{
for (j = 0; j < num_columnas; j++)
cout<< matriz[i][j];
cout<<'\n';
}
}

La salida es:
0 1 2 3 4 5 6
1 2 3 4 5 6 7
2 3 4 5 6 7 8
3 4 5 6 7 8 9

Arrays multidimensionales
C permite arrays de más de dos dimensiones. El límite exacto, si lo hay, viene determi-
nado por el compilador.
La forma general de declaración de un array multidimensional es:
especificador_de_tipo nombre_array [tam_1] [tam_2] ... [tam_n];
NOTA: tam_1, tam_2, ..., tam_n han de ser expresiones constantes.
La forma general de acceso es:
nombre_array [ind_1] [ind_2] ... [ind_n]

La Clase String y sus Métodos más Importantes en C+

+
Los métodos más usados del tipos String.
Declaración y Asignación a un tipo string.
A un objeto que hayamos declarado como tipo string, se le pueden asignar otros objetos
del mismo tipo, cadenas entre comillas dobles, lo anterior lo ilustramos en el siguiente
ejemplo de código:

#include <iostream>
#include <string>

using namespace std;

Pág. 12
int main()
{
//forma de inicializar y asignar una cadena
string cad_1 = "Hola mundo";

string cad_2 = "Segunda asignación";

//asignar/copiar cad_1 en cad_2

cad_2 = cad_1;

return 0;
}

Acceso a un caracter del tipo string.

La forma más común y fácil de acceder a un caracter en una determinada posición que
queramos es mediante el uso de [] (corchetes) cómo se hace con los arrays, de esta for-
ma si tenemos un tipo string de nombre str al cual le asignamos la palabra “programa” y
queremos que se nos retorne la letra que está en la posición 3 (contando desde cero,
como siempre) entonces el código sería el siguiente.

#include <iostream>
#include <string>

using namespace std;

int main()
{
//definimos la cadena str
string str;

//le asignamos el contenido “programa”;

str = "programa";

//mostramos en consola cual es el caracter

//en la posición 3 (contando desde 0)
cout<<str[3]<<endl<<endl;

return 0;
}
Cuando el código es ejecutado, nos indicará que la letra en la posición 3 de la cadena str es el caracter ‘g’.
Comparaciones entre strings.

La comparación entre objetos string se puede llevar a cabo fácilmente mediante el uso
de los operadores ==, <=, >=, <, >, !=, que son los mismos que se usan para las opera-
ciones de tipo lógicas, hay que aclarar que se distingue entre mayúsculas y minúsculas.

Se puede saber cuando una cadena está antes alfabéticamente hablando (es menor) o
está después de la otra (es mayor) esto se debe a la organización de las letras mayúscu-
las y minúsculas en el estándar ascii.

En el siguiente ejemplo tenemos dos cadenas (str1 y str2) ambas con las cadenas “abcd”
y “abcd” respectivamente, por lo tanto si las comparamos ambas cadenas deben ser
iguales y el programa nos lo indicará en la terminal (consola).

Pág. 13
#include <iostream>
#include <string>

using namespace std;

int main()
{
//creamos y asignamos las cadenas str1 y str2
string str1="abcd", str2="abcd";
cout<<endl;
//comparamos si las cadenas son iguales
if(str1==str2)
{
cout<<"str1 es igual a str2"<<endl<<endl;
}

return 0;
}

El resultado de la ejecución, como se esperaba es que se que cumple la igualdad.

Concatenación de Strings.

El operador ‘+’ (más) nos permite concatenar dos o mas cadenas, entonces en el si-
guiente ejemplo si tengo a str1, str2 que contienen las cadenas “Julio” y “Cesar” respec-
tivamente puedo unir (concatenar) el contenido de str2 a str1 solo poniendo str1 = str1 +
str2, el código es:

#include <iostream>
#include <string>

using namespace std;

int main()
{
//definimos e inicializamos ambas cadenas
string str1="Julio ", str2="Cesar";

//realizamos la concatenación de ambas variables

str1+=str2;

//mostramos el nuevo contendio de str1

cout<<"El nuevo contenido de str1 es: "<<str1<<endl;
return 0;
}

Cómo se puede ver, el nuevo contenido de la cadena str1 es “Julio Cesar”.

Búsqueda de subcadenas o caracteres dentro del tipo string.

Dentro de las operaciones permitidas o implementadas en el lenguaje, se puede llevar a

cabo las búsqueda de subcadenas o caracteres dentro de nuestro objeto string es decir
que en una cadena como “esta es mi casa” podemos buscar y obtener la posición donde

Pág. 14
aparezca la palabra “mi” que sería la posición 8 (como siempre contando desde 0 en
este lenguaje). Son muchos los métodos ‘.find‘ que implementa la clase string de C++,
algunos de los más usados se presentan en el siguiente código, el cual puedes manipular
para observar los diferentes comportamientos. La explicación de cada uno está en los
comentarios del código.

#include <iostream>
#include <string>

using namespace std;

int main()
{
string str = "abcdefgh";

//a continuación buscamos la subcadena "wkf" entre str, si no está

presente, retorna la constante npos
//que es equivalente a NULL en el tipo string, en este código se
mostrará que la cadena no fue encontrada
//el método find() nos retorna la prosición del primer caracter del
arguento que aparece en la cadena str.
if(str.find("wkf")==string::npos)
cout<<"cadena no encontrada"<<endl;
else
cout<<"cadena encontrada.."<<endl;

cout<<str.find_first_of("cde")<<endl; //retorna la posición del

caracter que aparezca primero de esos 3

cout<<str.find_last_of("cde")<<endl; //retorna la posición del

caracter que aparezca de último entre esos 3

cout<<str.find_first_not_of("cde")<<endl;//retorna la posición del

primer caracter en str que sea diferente a todos los del argumento

cout<<str.find_last_not_of("cde")<<endl; // retorna la posición del

ultimo caracter en str que sea diferente de todos los del argumento

return 0;
}

Obtener subcadenas de una cadena principal.

Uno de los métodos que se usan frecuentemente es el que nos permite obtener una sub-
cadena a partir de una principal, decir, si por ejemplo tengo una cadena “Hola Mundo”
puedo obtener una segunda cadena y hacer que esta almacene la palabra “Mundo” de la
cadena principal, esto lo logramos con el método .substr() que en su forma más básica
recibe 2 parámetros, el primero de ellos indica la posición del primer caracter a obtener
y el segundo parámetro indica cuantos caracteres tomaremos (a partir del que se tomó
primero). Lo anterior lo ilustramos en el siguiente código, donde str1 contiene “Hola
Mundo” y str2 va a contener la cadena “Mundo” que vamos a extraer de str1.

#include <iostream>
#include <string>

Pág. 15
using namespace std;

int main()
{
//definimos los objetos string que vamos a usar
string str1="Hola Mundo";
string str2;

//asignamos a str2 la subcadena que está desde la posición 5 "M"

str2=str1.substr(5,5); //"Mundo"

//mostramos los contenidos

cout<<"El contenido de str1 es: "<<str1<<endl;
cout<<"El contenido de str2 es: "<<str2<<endl;
return 0;
}

Obtener y modificar el tamaño de una string.

Tenemos dos métodos .length() y .size() ninguno recibe parámetros y ambos nos retor-
nan la longitud de la cadena (string) con la cual invoquemos el método, ambos tienen
como retorno un tipo Int.

#include <iostream>
#include <string>

using namespace std;

int main()
{
//definimos la cadena y la inicializamos
string str="Hola!";

//mostramos los valores con diferentes métodos

cout<<"Longitud con el método .length(): "<<str.length()<<endl;
cout<<"Longitud con el método .size(): "<<str.size()<<endl;

return 0;
}

Saber si el objeto string está vacío o contiene datos.

Este método es bastante útil cuando tratamos con interfaces de usuario y tenemos que
validar si algún campo de texto de la interfaz contiene o no contiene datos, el método
.empty() presente en string, nos retorna un true si la cadena está vacía, o false si la ca-
dena contiene datos.

En el siguiente código definimos una string str vacía, y luego invocamos el método
empty() para verificar que no posea ningún contenido, en este caso como es obvio, la
condición se cumplirá y el programa nos dirá que ese objeto string se encuentra vacío.

Pág. 16
#include <iostream>
#include <string>

using namespace std;

int main()
{
//definimos la cadena y la dejamos sin contendio
string str="";

//preguntamos a .empty() si está vacía

if(str.empty()==true)
{
cout<<"\nLa cadena str se encuentra vacia.."<<endl<<endl;
}
else
{
cout<<"La cadena str contiene informacion.."<<endl;
}

return 0;
}

Leer cadenas desde el teclado.

En C++ disponemos de dos métodos para capturar la entrada de texto desde el teclado,
los cuales son el flujo cin y la función getline(), ¿cuál es la diferencia?, bueno, la dife-
rencia radica en que con el flujo cin leemos una cadena solo hasta que encontremos un
espacio, entonces si por ejemplo ingresamos desde el teclado la cadena “Julio César”
entonces el objeto cin nos retornará solo “Julio” y lo que esté después del espacio se
quedará en el buffer, por lo tanto el flujo cin, aunque no es común, lo podemos usar
para cuando estamos seguros que el dato que se ingresará solo será una palabra (no in-
gresarán ‘espacios’). Por otro lado tenemos el método getline(cin,Objeto_string) que re-
cibe dos parámetros uno de ellos es ‘cin‘ que le indica que la lectura se hará desde la en-
trada estándar (teclado) y el siguiente parámetro es el objeto string donde queremos que
se almacene la información ingresada, así de simple.

Para ilustrar todo lo que se dijo anteriormente, ingresaremos desde el teclado la cadena
“Hola Mundo” y observaremos los resultados de capturar esa información con los dos
métodos que se describieron.

#include <iostream>
#include <string>

using namespace std;

int main()
{
//definimos la cadena y la dejamos sin contendio
string lectura1, lectura2;

//se pide el ingreso de la cadena

//dos veces para hacer dos lecturas
cout<<"\nIngrese la palabra: ";
cin>>lectura1;
//limpiamos el buffer antes de la siguiente lectura

Pág. 17
cin.ignore(256,'\n');
cout<<"\nIngrese nuevamente la palabra: ";
getline(cin,lectura2);

//imprimendo el resultado de las lecturas

cout<<"\nCapturando con cin>>lectura1 se obtuvo:
"<<lectura1<<endl<<endl;
cout<<"Capturando con getline(cin,lectura2) se obtuvo:
"<<lectura2<<endl<<endl;
return 0;
}

Pág. 18