Universidad Politécnica de Sinaloa

SAPERE, DUBITARE ET INNOVARE

Ingeniería en Informática

Fundamentos de programación estructurada

Grupo 2-3

Introducción a la
programación estructurada

Alumno: Matrícula:
Germain Ramirez Cristal Esmeralda 2017030709
Guerra Pérez Roberto 2017030990

Profesor Andrés Echeagaray Osuna

9 de enero de 2018. Mazatlán, Sinaloa, México.

Contenido
Introducción ....................................................................................................................................... 3
Etapas de desarrollo de un software. ............................................................................................ 4
Análisis de requisitos ............................................................................................................... 4
Diseño y arquitectura ................................................................................................................ 4
Programación .............................................................................................................................. 4
Pruebas ......................................................................................................................................... 4
Documentación ........................................................................................................................... 4
Mantenimiento............................................................................................................................. 4
Elementos de un programa en C#. ................................................................................................ 5
Identificadores ............................................................................................................................ 5
Operadores .................................................................................................................................. 5
Tipos de datos básicos............................................................................................................. 5
Variables ....................................................................................................................................... 5
Constantes ................................................................................................................................... 5
Estructuras condicionales ....................................................................................................... 6
Operadores aritméticos ................................................................................................................... 6
Operadores lógicos .......................................................................................................................... 6
Prioridad de operadores .................................................................................................................. 7
Programación estructurada............................................................................................................. 7
Estructuras de control selectivas ................................................................................................... 7
Estructuras de control repetitivas ................................................................................................... 8
Datos de tipo estructurado (Arreglos) ........................................................................................... 8
Funciones .......................................................................................................................................... 8
Conclusión ....................................................................................................................................... 10
Referencias ..................................................................................................................................... 10
Introducción
Realizar un programa sencillo requiere de un conocimiento básico en cuanto a elementos
y sintaxis de dicho programa, por tal motivo, comenzar a cultivar nociones de la
programación estructurada es necesario.

A continuación se observa una introducción al curso de programación estructurada, la cual

contiene las fases necesarias para desarrollar software, los elementos de un programa (en
el lenguaje C#), operadores, estructuras de control, así como una pequeña explicación de
arrays y funciones.
Etapas de desarrollo de un software.
Análisis de requisitos

Extraer los requisitos de un producto de software es la primera etapa para crearlo; de esta
etapa depende en gran medida el logro de los objetivos finales.

Diseño y arquitectura

Se refiere a determinar cómo funcionará de forma general sin entrar en detalles. Consiste
en incorporar consideraciones de la implementación tecnológica, como el hardware, la red,
etc.

Programación

Reducir un diseño a código puede ser la parte más obvia del trabajo de ingeniería de
software, pero no es necesariamente la porción más larga. La complejidad y la duración de
esta etapa está íntimamente ligada al o a los lenguajes de programación utilizados.

Pruebas

Consiste en comprobar que el software realice correctamente las tareas indicadas en la

especificación. Una técnica de prueba es probar por separado cada módulo del software, y
luego probarlo de forma integral, para así llegar al objetivo.

Documentación

Todo lo concerniente a la documentación del propio desarrollo del software y de la gestión

del proyecto, pasando por modelaciones (UML), diagramas, pruebas, manuales de usuario,
manuales técnicos, etc.; todo con el propósito de eventuales correcciones, usabilidad,
mantenimiento futuro y ampliaciones al sistema.

Mantenimiento

Mantener y mejorar el software para enfrentar errores descubiertos y nuevos requisitos.

Esto puede llevar más tiempo incluso que el desarrollo inicial del software. Alrededor de 2/3
de toda la ingeniería de software tiene que ver con dar mantenimiento. Una pequeña parte
de este trabajo consiste en arreglar errores, o bugs. La mayor parte consiste en extender el
sistema para hacer nuevas cosas.
Elementos de un programa en C#.

Identificadores

Es un nombre con el que se identifica algún elemento del código.

Operadores

Operadores aritméticas: suma (+), resta (–), producto (*), división (/) y módulo (%), menos
unario (– –) y más unario (+ +).

Operaciones lógicas: “and” (&& y &), “or” (| | y |), “not” (!) y “xor” (^).

Operadores relacionales: igualdad (= =), desigualdad (! =), mayor que (>), menor que (<), mayor
o igual que (> =) y menor o igual que (< =).

Operador de asignación: Para realizar asignaciones se usa en C# el operador. Por ejemplo, la

expresión a = b asigna a la variable a el valor de la variable b y devuelve dicho valor.

Operadores de asignación compuestos:Son operadores de asignación compuestos: + =, – =, *

=, / =.

Operadores de concatenación: Para realizar operaciones de concatenación (unión) de cadenas

se puede usar el mismo operador que para realizar sumas (+).

Tipos de datos básicos

Son elementos de datos que permiten definir el tipo a las variables, constantes, parámetros,
etc., para que C# reserve un espación en memoria de acuerdo al tipo y al tamaño de estos.

Variables

Es un elemento del programa conocido por un nombre o identificador, que pertenece a un

tipo de dato definido. Es un almacén de objetos de un determinado tipo al que se le da un
cierto nombre. Para definir una variable sólo hay que decir cuál será el nombre que se le
dará y cuál será el tipo de dato que podrá almacenar, Ejemplo:

<tipoVariable> <nombreVariable>;

int numero;

Constantes

Son los elementos del programa que no cambian de valor a lo largo del algoritmo. Las
constantes se definen como variables normales pero precediendo el nombre de su tipo del
modificador const y dándoles siempre un valor inicial al declararlas, Ejemplo:

const <tipoConstante><nombreConstante> = <valor>;

 constint x = 5;

Estructuras condicionales

Son instrucciones que permiten ejecutar bloques de instrucciones sólo si se da una

determinada condición.

Estructura condicional If.

Se evalúa la expresión <condición>, que ha de devolver un valor lógico. Si es cierta

(devuelve true) se ejecutan las <instruccionesIf, y si es falsa (false) se ejecutan las
<instruccionesElse>.

Estructura condicional Switch.

Se evalúa <expresión>. Si su valor es <valor1> se ejecuta el <bloque1>, si es <valor2>

se ejecuta <bloque2>, y así para el resto de valores especificados. Si no es igual a
ninguno de esos valores y se incluye la rama default, se ejecuta el <bloqueDefault>; si
no se incluye se pasa directamente a ejecutar la siguiente instrucción.

Operadores aritméticos
Hay 2 tipos de operadores aritméticos: unarios y binarios. Los operadores
unarios devuelven expresiones del mismo tipo que la expresión a la que afectan.
Por ejemplo, -4 es el resultado de aplicar el operador unario (–) al entero 4,
devolviendo otro número entero. Binarios:

Operador Operación
+ Suma
- Resta
* Multiplicación
/ División
div División entera
mod Módulo (resto)

Operadores lógicos
Se usan para comparar dos variables o expresiones y obtener un valor verdadero o falso.

SÍMBOLO SIGNIFICADO EJEMPLO

= Igual que A=B
> Mayor que A>B
< Menor que A<B
 >= Mayor o igual que A >= B
<= Menor o igual que A <= B
<> Distinto que A <> B

Prioridad de operadores
La jerarquía de operadores es la siguiente:

1. Paréntesis; ( ).
2. Exponenciación; ^-
3. Multiplicación (*), división ( / ).
4. Suma (+), resta ( - ).
5. Resto (mod), cociente ( \ ).
6. Igual (=), distinto (<>), mayor (>), menor (<), mayor o igual (>=), menor o igual (<=).
7. No (Not)
8. Y (And).
9. O (Or).

Programación estructurada
La programación estructurada es un estilo con el cual se busca que el programador
elabore programas sencillos y fáciles de entender. Para ello, la programación estructurada
hace uso de tres estructuras básicas de control:

Estructura Secuencial

Estructura Selectiva

Estructura Repetitiva

Estructuras de control selectivas

Indica que las instrucciones de un programa se ejecutan una después de la otra, en el
mismo orden en el cual aparecen en el programa.
Estructuras de control repetitivas
Plantea la selección entre dos alternativas con base en el resultado de la evaluación de
una condición; equivale a la instrucción IF de todos los lenguajes de programación.

Datos de tipo estructurado (Arreglos)

Los tipos de datos estructurados más comunes son: vectores y matrices (array), cadenas
de caracteres (string), registros y uniones.

Un arreglo sirve para agrupar variables de un mismo tipo con un único nombre. Por ejemplo,
se desea declarar 10 variables de tipo entero. Una forma de hacerlo es mediante variables
individuales: int a0, a1, a2, a3, a4, a5, a6, a7, a8, a9; Y si se quisiera inicializarlos a 0,
habría que escribir 10 asignaciones. Otra forma de hacerlo es utilizando un vector (arreglo
o array). La forma de declarar un vector es la siguiente:

Tipo Nombre [NumElementos]

Donde Tipo indica el tipo de datos de los elementos del vector. El tipo puede ser cualquier
tipo de dato, sea simple o estructurado. NumElementos es el número de elementos que
contiene el vector. Tiene que ser siempre una constante de tipo entero.

Funciones
Una función es un procedimiento que, adicionalmente, devuelve un valor como resultado
de su ejecución.

La ventaja de las funciones es que pueden utilizarse en asignaciones, expresiones

matemáticas, etc.

Sintaxis:

public int Maximo (int x, int y)

{
int mayor;
if (x==y)
return -1;
else if (x>y)
return x;
else
return y;
}
En la anterior sintaxis, public es el nivel de acceso, indica que puede ser accedida desde
cualquier scrip, dentro o fuera del archivo donde se declaró; int, es el valor que retornará la
función, en este caso como es un numero el que tiene que retornar, pero no siempre es así,
algunas veces, hay funciones que piden de argumento un string y retornan un bool u otro
tipo de datos; Maximo, es el nombre de la función; (int x, int y) son los argumentos de la
función, los valores que necesita para operar, en este caso son dos, siempre se separan
con una coma y se debe de definir el nombre y el tipo de datos.

Y dentro de esta función utiliza los argumentos que pide y realiza la comparación, lo de
adentro es un if.
Conclusión
La programación estructurada busca que los programas sean sencillos y entendibles, así
como más comodidad y un mejor desarrollo para el programador.

Para elaborar un programa, es necesario conocer los elementos que lo conforman, como
las variables (dato que puede tomar distintos valores a lo largo del programa), los
operadores (signos utilizados para realizar acciones como sumas, restas, comparaciones,
etc.), entre otros. Además, es importante conocer la sintaxis; lo que conlleva estructuras
condicionales, como el if, que compara una variable con otra variable del mismo tipo y forma
una comparación, la cual dirige a más acciones en el código, dependiendo de su verdad.
Por otro lado, las funciones que existen en la programación son herramientas que ahorran
arduo trabajo, extienden las posibilidades de éxito en el programa y optimizan el mismo.

Y, en cuanto a optimización, los arrays son conjuntos de variables (del mismo tipo) que
sustituye cada variable escrita individualmente (todas ellas se agrupan formando un arreglo)
y son esenciales para un programa que requiere muchas variables, pues permiten una
mejor organización en el código y, por tanto, mejor rendimiento de parte del desarrollador.
Referencias

Celaya, I. T. (s.f.). Programación estructurada. Recuperado el 9 de enero de 2018,

de http://www.iqcelaya.itc.mx/~vicente/Programacion/ProgEstruct.pdf

Docente. (24 de abril de 2012). Elementos del lenguaje C#. Recuperado el 9 de

enero de 2018, de https://docentefarem.wordpress.com/2012/04/24/elementos-del-
lenguaje-c/

Rancel, M. (s.f.). Operadores lógicos o de comparación en programación. Ejemplos.

Recuperado el 1 de enero de 2018, de
https://www.aprenderaprogramar.es/index.php?option=com_content&view=article&
id=272:operadores-logicos-y-de-comparacion-en-programacion-not-and-or-
ejemplos-cu00132a&catid=28&Itemid=59

Roldán, Á. (10 de octubre de 2016). Operadores aritméticos. Recuperado el 9 de

enero de 2018, de http://www.ciberaula.com/articulo/operadores_arismeticos/

Waldestrand. (5 de julio de 2008). Fases del proceso de desarrollo de software.

Recuperado el 9 de enero de 2018, de
https://sistemasvd.wordpress.com/2008/07/05/fases-del-proceso-de-desarrollo-del-
software/

Wizard. (28 de abril de 2009). Procedimientos y funciones. Recuperado el 9 de enero

de 2018, de http://developershn.blogspot.mx/2009/04/procedimientos-y-
funciones.html