República Bolivariana de Venezuela

Ministerio del Poder Popular para la Educación Universitaria

Universidad Nacional Experimental de la Gran Caracas.
Núcleo: La Floresta
Cátedra: Algorítmica y Programación
Prof. Luis Marchena

Estructuras de Control

Integrantes:
David Alejandro Montes Mendez. C.I. 28.387.069 Telf.: 0412-026.46.26
Danielis Guzman Leon C.I. 16.880.982 Telf.: 412-376.75.22
Josué Abraham Muñoz Zambrano C.I. 29.100.456 Telf.: 0412-555.70.02
Juan Carlos Gabriel Navas González C.I. 28.326.698 Telf.: 0412-308.29.46

Caracas, 08 de enero del 2024

 Sentencia Condicional “ if, else ”:

La sentencia if es una estructura de control que permite a un programa tomar decisiones.

Si una condición es verdadera, el programa ejecuta un bloque de código. Si la condición
es falsa, el programa ejecuta un bloque de código diferente o no hace nada.

La sintaxis básica de la sentencia if es la siguiente:

if (condición)
{
Bloque de código que se ejecuta si la condición es verdadera
} else {
Bloque de código que se ejecuta si la condición es falsa
}

Por ejemplo, la siguiente sentencia if comprueba si una variable edad es mayor o igual
que 18. En el “ if “primero verifica si la condición se cumple (verdadero), si lo es, se
ejecuta el bloque de código, si no se cumple (falso), ejecuta el bloque de código“ else “

if (edad >= 18)

{
cout<<”El usuario es mayor de edad”;
}
Else
{
Cout<<”El usuario es menor de edad”;
}

Operador Condicional Ternario o ” ? : “

El operador ternario es una forma concisa de escribir una condición y asignar un valor en
función de si la condición se cumple o no. Es parecida a la condicional if, es usada si se
necesitas dos resultados posibles, si necesitas escribir más líneas de código, es mejor
utilizar la sentencia if.

La sintaxis básica de la sentencia ternario es la siguiente:

condicion ? valor_verdadero : valor_falso

Por ejemplo, el siguiente fragmento de código se asigna el valor a la variable “edad”,

Si en el valor ingresado en la variable edad es igual o mayor a 18 (edad>=18), el
resultado (verdadero) será lo que este después del signo de interrogación (?), si la
condición no se cumple (falso), entonces el resultado será lo que este después de los dos
puntos ( : )
Int edad = 18;
edad >= 18 ? cout<<"mayor de edad" : cout<<"menor de edad";

Condicional Swicht

La instrucción switch es una estructura de control condicional de múltiples opciones

similar a la de if pero con mayor simplicidad para casos específicos. Te permite
seleccionar de varios bloques de código basados en el valor que el operador asigne.

La sintaxis básica de la sentencia swicht es la siguiente:

Switch (expresión)
{
case value1:
código a ejecutar si expresión es igual a value1
break;
case value2:
código a ejecutar si expresión es igual a value2
break;
default:
código a ejecutar si no coincide con ningún case anterior
break;
}

Elementos:

 expresión: Es cualquier expresión válida que devuelva un valor entero..

 case valueX: Cada case especifica un valor posible de la expresión. Los valores
en los case deben ser únicos y distintos.

 break: Esta es una palabra clave opcional que indica que se debe salir del switch
después de ejecutar el código del case correspondiente. Si no se utiliza, el control
fluye al siguiente case a menos que una instrucción lo detenga.

 default: Es un caso opcional que se ejecuta si la expresión no coincide con ningún

valor de los case anteriores
En el siguiente ejemplo, se puede expresar el código Swicht, donde se le pide al usuario
un valor del 1 al 5, y dependiendo del valor ingresado, se ejecutará el “case”
correspondiente.

int numero;

cout<<"Digite un numero entre 1-5: ";

cin>>numero;
switch(numero)
{
case 1: cout<<"Es el número 1"; break;

case 2: cout<<"Es el número 2"; break;

case 3: cout<<"Es el número 3"; break;

case 4: cout<<"Es el número 4"; break;

case 5: cout<<"Es el número 5"; break;

default: cout<<"No está en el rango de números"; break;

}

Ciclo While

Un ciclo while es una estructura de control que permite a un programa ejecutar un bloque
de código repetidamente, mientras que una condición sea verdadera

La sintaxis básica de un ciclo while es la siguiente:

while (condición)
{
Bloque de código que se ejecuta repetidamente
}
La condición se evalúa al comienzo de cada iteración del ciclo. Si la condición es
verdadera, el bloque de código se ejecuta. Si la condición es falsa, el ciclo se termina.

Por ejemplo, el siguiente código utiliza un ciclo while para imprimir los números del 1 al
10:

Se puede expresar una variable ( i ) con un valor asignado ( 1 ), donde la condición es: si “
i “ es menor o igual a 10. Si esta condición se cumple, el bloque de código se ejecutará
hasta que esta condición sea falsa. Dentro del bloque de instrucciones, se suma un
incremento de 1 a la variable i (i++) para que el valor aumente hasta que este sea mayor
a 10 y se finalice el ciclo.
Es importante colocar “ std::endl; “ para que esa línea se finalice y el siguiente ciclo se
ejecute en la siguiente línea.

int i = 1;

while (i <= 10)

{
cout << i << std::endl;
i++;
}

Ciclo Do-While
Diferencia del while y do-while

La diferencia es que el do-while, primero ejecuta la acción y luego evalúa la condición,

mientras que el while evalúa la condición antes que cualquier cosa. Esto quiere decir, que
el ciclo while podría no ejecutar ni siquiera una vez lo que tenga en su interior, mientras
que el do-while te asegura que lo que pongas dentro se ejecute mínimo una vez, pues
primero ejecuta y luego evalúa la condición

La sintaxis básica de un ciclo while es la siguiente:

Do
{
Bloque de código
} while (condición)

Ejemplo. En el siguiente código, se va a ejecutar los números del 1 al 10, como en el

ejemplo anterior, la única diferencia es que, se va a ejecutar sea lo sea que tengamos
dentro del ciclo “ do “ al menos una vez, antes de leer la condición que tengamos en e l“
while “

int i = 1;

do {
std::cout << i << std::endl;
i++;
} while (i <=10);

Ciclo for

Un ciclo “ for “es una estructura de control iterativa, que nos permite ejecutar de manera
repetitiva un bloque de instrucciones, conociendo previamente un valor de inicio, un
tamaño de paso y un valor final para el ciclo.

Li sintaxis básica del ciclo for es la siguiente:

for (int i = valor inicial; i <= valor final; i = i + paso)

{
Bloque de Instrucciones....
}

Ejemplo. En el siguiente código, vamos a mostrar los números pares del 0 al 20

(2..4..6..8..16..18..20). Primero necesitamos saber nuestro valor inicial que es 0, ahora
nuestro valor final que es 20, y por último, el número de pasos que debe haber para que
sea en números pares ( i += 2 ) esto es lo mismo que escribir, ( i = i + 2 ).

Se puede ver que el valor final es de 20, entonces se leería de esta manera: i es menor o
igual a 20 (verdadero): se ejecuta el código, cambiando el valor de i que es de 0 a 2,
sucesivamente hasta que llegue a 20.

int i=0;

for (int i=0;i<=20;i+=2)

{
cout << i <<std :: endl;
}
 Funciones

Una función en es un bloque de código que realiza una tarea específica. Una función
puede ser llamada desde cualquier parte del programa, lo que permite dividir el programa
en partes más pequeñas y manejables. Una función puede hacer las mismas acciones
que un programa.

Se distinguen 3 características: la definición, la declaración y la llamada.

La sintaxis básica de una función es la siguiente:

tipo nombre_de_la_funcion (lista_de_parametros)

{
código de la función
return valor_de_retorno;
}

Elementos:

 tipo: El tipo de dato que se devolverá desde la función.

 nombre_de_la_funcion: El nombre de la función.

 lista_de_parametros: Una lista de variables que se pueden pasar a la función

como entrada.

 código de la función: El código que se ejecutará cuando se llame a la función.

 return valor_de_retorno: La instrucción return se utiliza para devolver un valor

desde la función.

Prototipo

Nota: un prototipo de función es una declaración de una función que no incluye su

cuerpo. Los prototipos se utilizan para indicar al compilador el tipo de datos que se
devolverán desde la función y los tipos de datos de los parámetros que se pasan a la
función.

Ejemplo. En el siguiente código podemos ver un prototipo encima de la función principal

(main) llamado “suma“, en su encabezado podemos ver que es de tipo entero (int), y
dentro de los paréntesis (parámetros o variables) podemos ver “int a, int b“, dos variables
de tipo entero, se abren los corchetes para escribir el bloque de código que vayamos a
ejecutar.

Para nosotros crear una función, se debe declarar encima de la función principal (main), y
definirla debajo de la función principal (main), es decir, le decimos al programa que existe
una función llamada suma (a esto se le llama prototipo), declarada encima de la función
principal y se realiza la operación por debajo, sea una suma, resta o lo que vayamos a
ejecutar dentro de esa función. Debemos tener en cuenta que en la “Definicion” de la
función, debe retornar un valor “return”, es decir que dentro de la función principal main,
cuando vayamos a llamar la función, que en este caso es suma, se le debe colocar el
valor de la suma en el “return” de la definición, de esta manera, la función podrá retornar a
la función principal, y darnos los valores de operación que se hicieron dentro de la función
“suma”.

Ahora bien, en la función principal, le pedimos al usuario dos números (numero1,

numero2),
Declaramos una variable de tipo entero llamada “resultado” para guardar el resultado de
la función que se va a llamar, en este caso se llama a la función “suma” y dentro de los
paréntesis, vamos a colocar las variables que declaramos en la función principal
(numero1, numero2).

Se coloca numero1 y numero2 porque ahí es donde el usuario está colocando los
números a sumar. También debemos tener en cuenta que el orden como se coloque las
variables dentro de los paréntesis en la “llamada” es el mismo orden como lo va a tomar la
función que estemos llamando, es decir, si en la llamada de la función colocamos dentro
del paréntesis (numero1, numero2), en la operación de la función “suma”, lo tomara como
“a” para numero1 y “b” para numero2.
Ahora solo lo se muestra por pantalla el resultado, y de esta manera tenemos una función
de suma sin necesidad de tener ese código dentro de la función principal.

int suma(int a, int b); // Declaración, también llamada prototipo

int main()
{
int numero1, numero2;
cout << "Introduzca el primer número: ";
cin >> numero1;
cout << "Introduzca el segundo número: ";
cin >> numero2;

int resultado = operación (numero1, numero2); // Llamada

cout << "La suma de "<< numero1 << " y " << numero2
<< " es " << resultado << ".\n";
}
// Definición
int suma (int a, int b)
{
int operacion;
operacion = (a+b);
return operacion; //Valor que va a retornar en la función principal

Funcion Void

En ocasiones una función no necesita devolver ningún valor y, por tanto, no es obligatorio
usar return.

Para ello, debemos definir la función con un tipo especial llamado void.

Ejemplo.
En este caso solo se desea mostrar un mensaje en cadena, no necesita retornar ningún
valor, solo se llama la función, y se muestra lo que esta en el bloque de código.

void imprime_cadena(string cadena)

{
cout << cadena;
// return; // Opcional
}
int main()
{
string cadena = "Hola";
imprime_cadena(cadena);
imprime_cadena(" mundo.\n");
}

Funciones sin argumentos

Funciones sin argumentos

Una función puede no necesitar una lista de parámetros.

Ejemplo

//Opcional void imprime_mensaje_inicial(void)

void imprime_mensaje_inicial() // Sin parametros
{
cout << "Este programa bla bla bla…\n";
}

int main()
{
imprime_mensaje_inicial(); //Solo se necesita llamar la función y mostrar lo que este
dentro.
}

Paso de Argumentos

En C++, existen dos pasos de argumentos principales:

Paso por valor: En este paso, los argumentos se copian en la pila de la función. Esto
significa que la función recibe una copia de los datos originales, y cualquier cambio que
realice en la copia no afectará a los datos originales.

Paso por referencia: En este paso, se pasa una referencia a los datos originales. Esto
significa que la función puede acceder y modificar directamente los datos originales.

Sintaxis:
Paso por valor:
tipo nombre_de_la_funcion(tipo argumento1, tipo argumento2)

Paso por referencia:

tipo nombre_de_la_funcion(tipo &argumento1, tipo &argumento2) // Se le coloca
apersand (&)

Paso por referencia

En este ejemplo, la función incrementa() recibe un argumento de tipo entero llamado a. El

argumento a se pasa por referencia, por lo que se pasa la dirección de x a la función.

Cuando la función incrementa() incrementa el valor de a, incrementa el valor real de x

void incrementa(int &a)

{
a++;
}

int main() {
int x = 10;
 incrementa(x);

std::cout << "El valor de x es: " << x << std::endl;

return 0;
}

Paso por valor

En este ejemplo, la función incrementa() recibe un argumento de tipo entero llamado a. El

argumento a se pasa por valor, por lo que se crea una copia de x en el ámbito de la
función incrementa().

Cuando la función incrementa() incrementa el valor de a, solo incrementa la copia de x

que se creó en su ámbito. El valor original de x permanece sin cambios.

void incrementa(int a)
{
a++;
cout<<” ”<<a; // El valor de a es 11, ya que toma la x por valor y le realiza el
incremento que se está pidiendo.
}

int main()
{
int x = 10;

incrementa(x);

std::cout << "El valor de x es: " << x << std::endl; // El valor de x sigue siendo 10, no
hay modificación

return 0;
}

Valores de retorno

El valor de retorno de una función es un valor que se devuelve a la función que la llamó.
Este valor puede ser de cualquier tipo, incluyendo tipos primitivos, tipos de puntero, tipos
de referencia y tipos complejos.

Las funciones que devuelven un valor deben especificar el tipo de valor devuelto en su
declaración
 1. Ejemplo
Por ejemplo, la siguiente función devuelve un valor entero:
La función sumar() devuelve la suma de los valores de los argumentos a y b.
Para devolver un valor de una función, se utiliza la instrucción return. La
instrucción return puede tener una expresión como operando. La expresión se
evalúa y su valor se devuelve a la función que llamó.

int sumar(int a, int b)

{
return a + b; //Instrucción return tiene una expresión de suma.
}

2. Ejemplo

La siguiente función devuelve la suma de los valores de los argumentos a y b,

pero devuelve un valor flotante:

C++
float sumar(int a, int b) //Se declara variables de tipo entero
{
return (float)a + (float)b; //Retorna valores de tipo flotante
}

3. Ejemplo

Las funciones que no devuelven ningún valor se declaran con el tipo de retorno
void. Por ejemplo, la siguiente función no devuelve ningún valor:

La función imprimir() imprime el mensaje especificado en el argumento mensaje

C++
void imprimir(const char* mensaje)
{
cout << mensaje; //No retorna valores
}

Macros

Una macro es una porción de código que se sustituye por su valor durante el proceso de
compilación. Las macros se definen mediante el símbolo.

Esto se coloca encima del cuerpo principal mai,.

#define.

Existen dos tipos principales de macros:

 Macros similares a objetos: Estas macros no toman argumentos y se sustituyen

por su valor literal. Por ejemplo, la siguiente macro define una constante simbólica:

Ejemplo:

#define VALOR_MACRO 100

int main()
{
cout<<”El valor del macro es: "<< VALOR_MACRO;
}

 Macros similares a funciones: Estas macros pueden tomar argumentos y se

sustituyen por el resultado de la evaluación de la expresión. Por ejemplo, la
siguiente macro define una función que imprime un mensaje:

#define maximo(a,b) (a > b) ? a : b

int main()
{
cout<<"El numero mayor entre 1 y 5 es: %d", maximo(1,5);
}

Esto puede ser útil si tienes que escribir varias veres el mismo código y quieres ahorrar
tiempo de tipeo, o bien, si quieres que sea más legible.

Recursividad
La recursividad es un concepto fundamental en matemáticas y computación que permite
definir una función en términos de sí misma. En C++, una función recursiva es una función
que llama a sí misma.

Las funciones recursivas se utilizan a menudo para implementar algoritmos que se

pueden expresar como una secuencia de pasos que se repiten. Por ejemplo, la función
factorial(), que calcula el factorial de un número, se puede implementar de forma
recursiva de la siguiente manera:

Ejemplo:
int factorial(int n)
{
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}

Esta función funciona dividiendo el problema en dos subproblemas más pequeños:

Si n == 0, entonces el factorial de n es 1.
De lo contrario, el factorial de n es n multiplicado por el factorial de n - 1.
La función factorial() se llama a sí misma hasta que n es igual a 0. En este punto, la
función devuelve 1.

Las funciones recursivas pueden ser una forma eficiente de implementar algoritmos
complejos. Sin embargo, es importante utilizarlas con cuidado para evitar bucles infinitos.

Condiciones de terminación recursiva

Para que una función recursiva sea correcta, debe tener una condición de terminación. La
condición de terminación es una condición que indica que la función ha alcanzado un
punto en el que puede dejar de llamarse a sí misma.

En el ejemplo anterior, la condición de terminación es n == 0. Cuando n es igual a 0, la

función ha calculado el factorial de un número y ya no necesita llamarse a sí misma.

Esto es código real se vería de la siguiente manera:

#include <iostream>
using namespace std;

int factorial(int n) {
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}
int main()
{
cout<<"factorial es: "<<factorial(7);

}
 Bibliografías
Sentencia if
https://www.mclibre.org/consultar/php/lecciones/php-estructuras-control-condicional-if.html

Ternario
https://es.stackoverflow.com/questions/384162/qu%C3%A9-hace-el-operador-en-c

Swicht
While
Do-while
For
https://www.programarya.com/Cursos/C++/Condicionales/Condicional-switch

Funciones
https://www2.eii.uva.es/fund_inf/cpp/temas/8_funciones/funciones.html

Paso de argumentos
Valores de retorno
Macros
https://gbenussi.wordpress.com/2013/07/29/macros-en-c-y-c/
Recursividad
https://bard.google.com/chat/4f87341f96f73f27