Scribd
Cargar
17 vistas7 páginas

Manual de Programacion Lenguaje C

Este manual sirve para el lenguaje c de programación

Cargado por

Gabriel Arteaga
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
17 vistas7 páginas

Manual de Programacion Lenguaje C

Este manual sirve para el lenguaje c de programación

Cargado por

Gabriel Arteaga
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 7

República Bolivariana De Venezuela.

Ministerio Del Poder Popular Para La Educación.


Universidad Nacional Experimental De La Gran Caracas UNEXCA.
Materia: Programación II
Trayecto III
Carrera: Informática.

Profesor:

Caracas, 12 de junio de 2024.


Capítulo 3: Control de Flujo

El control de flujo en C es fundamental para la creación de programas que


puedan tomar decisiones y repetir acciones hasta que se cumpla una
condición. Este capítulo explora las estructuras de control de flujo que permiten
a los programas ser más dinámicos y funcionales.

## Proposiciones y Bloques
Una proposición es una instrucción que el compilador de C ejecutará. Los
bloques son grupos de una o más proposiciones encerradas entre llaves `{}`
que se tratan como una sola unidad de ejecución.

```c
int main() {
// Bloque de una sola proposición
printf("Hola, mundo!\n");

// Bloque de múltiples proposiciones


{
int a = 5;
int b = 10;
printf("La suma es: %d\n", a + b);
}
return 0;
}
```

If-else
La estructura `if-else` permite ejecutar un bloque de código si una condición es
verdadera, y otro si es falsa.

```c
int numero = 10;
if (numero > 0) {
printf("El número es positivo.\n");
} else {
printf("El número es negativo o cero.\n");
}
```

Else-if
Para múltiples condiciones, se utiliza `else-if`, que permite encadenar varias
alternativas.

```c
int calificacion = 85;
if (calificacion >= 90) {
printf("Excelente\n");
} else if (calificacion >= 80) {
printf("Muy bien\n");
} else if (calificacion >= 70) {
printf("Bien\n");
} else {
printf("Necesitas estudiar más\n");
}
```

Switch
El `switch` es una estructura de control que selecciona una ejecución entre
múltiples alternativas basándose en el valor de una variable.

```c
char grado = 'B';
switch (grado) {
case 'A':
printf("Excelente\n");
break;
case 'B':
printf("Muy bien\n");
break;
case 'C':
printf("Bien\n");
break;
default:
printf("Necesitas estudiar más\n");
}
```

Ciclos while y for


Los ciclos `while` y `for` permiten repetir un bloque de código mientras se
cumpla una condición.

```c
// Ciclo while
int i = 0;
while (i < 5) {
printf("%d\n", i);
i++;
}

// Ciclo for
for (int j = 0; j < 5; j++) {
printf("%d\n", j);
}
```

Ciclos do-while
El ciclo `do-while` garantiza que el bloque de código se ejecute al menos una
vez.
```c
int k = 0;
do {
printf("%d\n", k);
k++;
} while (k < 5);
```

break y Continue
`break` termina el ciclo más cercano, mientras que `continue` salta al siguiente
ciclo de iteración.

```c
for (int l = 0; l < 10; l++) {
if (l == 5) {
break; // Termina el ciclo
}
if (l % 2 == 0) {
continue; // Salta a la siguiente iteración
}
printf("%d\n", l);
}
```

Goto y Etiquetas
El uso de `goto` puede hacer que el flujo del programa salte a una etiqueta
específica, aunque su uso no es recomendado por poder complicar la lectura
del código.

```c
if (numero < 0) {
goto etiqueta_negativo;
}
printf("El número es positivo o cero.\n");
goto fin;
etiqueta_negativo:
printf("El número es negativo.\n");
fin:
```

---

Este capítulo proporciona una visión general de las estructuras de control de


flujo en C, con ejemplos de código que ilustran su uso. Es importante practicar
y entender estos conceptos para escribir programas eficientes y mantenibles.

Capítulo 4: Funciones y la Estructura del Programa

Las funciones son el corazón de la programación en C, permitiendo


modularizar y reutilizar código. Este capítulo se enfoca en los conceptos
fundamentales de las funciones y cómo estas interactúan con el resto del
programa.

Conceptos Básicos de Funciones


Una función en C es un bloque de código que realiza una tarea específica. Se
define con un nombre, un tipo de retorno, y opcionalmente, parámetros de
entrada.

```c
// Ejemplo de una función simple en C
int suma(int a, int b) {
return a + b;
}
```

Funciones que Regresan Valores No-enteros


Las funciones pueden retornar cualquier tipo de dato, no solo enteros. Esto
incluye tipos flotantes, caracteres, punteros y más.

```c
// Función que retorna un valor flotante
double dividir(double numerador, double denominador) {
if(denominador != 0) {
return numerador / denominador;
} else {
return 0.0; // Retorno de un valor por defecto en caso de error
}
}
```

Variables Externas
Las variables externas son aquellas que se definen fuera de cualquier función y
son accesibles desde cualquier parte del programa.

```c
int contador_global; // Variable externa

void incrementarContador() {
contador_global++;
}
```

Reglas de Alcance
El alcance de una variable determina dónde es accesible dentro del programa.
Las variables pueden tener alcance local, global o de bloque.

```c
void funcion() {
int variable_local = 5; // Solo accesible dentro de esta función
}
```

Archivos Header
Los archivos de cabecera (`.h`) contienen declaraciones de funciones, macros
y definiciones de tipos que se comparten entre varios archivos de código
fuente.

```c
// archivo.h
ifndef ARCHIVO_H
define ARCHIVO_H

void funcionCompartida();

endif
```

Variables Estáticas
Las variables estáticas mantienen su valor entre llamadas a la función y solo
son inicializadas una vez.

```c
void funcionPersistente() {
static int contador = 0; // Solo se inicializa una vez
contador++;
printf("%d\n", contador);
}
```

Variables Registro
Las variables de registro son una sugerencia al compilador para utilizar un
registro de CPU para el almacenamiento, lo que puede optimizar el acceso.

```c
void funcionRapida() {
register int contador;
for(contador = 0; contador < 1000; contador++) {
// Código rápido
}
}
```

Estructura de Bloque
La estructura de bloque se refiere a cómo se organizan las instrucciones y
declaraciones en un programa.

```c
if(condicion) {
// Bloque de código
}
```

Inicialización
La inicialización de variables y estructuras es crucial para evitar
comportamientos indefinidos.

```c
int numero = 0; // Inicialización de una variable
```

Recursividad
La recursividad ocurre cuando una función se llama a sí misma. Es útil para
tareas como la búsqueda y ordenamiento.

```c
int factorial(int n) {
if(n <= 1) return 1;
return n * factorial(n - 1);
}
```

El Preprocesador de C
El preprocesador ejecuta instrucciones antes de que el código sea compilado,
como incluir archivos o definir macros.

```c
define PI 3.1416
include "archivo.h"
```

---

Este capítulo cubre los aspectos esenciales de las funciones y cómo estas se
integran en la estructura general de un programa en C. Comprender estos
conceptos es vital para el desarrollo de software eficiente y mantenible.

También podría gustarte