República Bolivariana de Venezuela.

Ministerio del Poder Popular para la Defensa

Universidad Nacional Experimental Politécnica de la
Fuerza Armada.
Estado Carabobo-Núcleo Guacara

Estudiante:
Evelyn Anais Calderón Aray
C.I: 26.389.147
6to Semestre
Turno diurno
Ing. de Telecomunicaciones
Sección 01

Junio, 2020
 Lenguaje C

El lenguaje de programación C fue creado por Brian Kernighan y Dennis Ritchie a

mediados de los años 70. La primera implementación del mismo la realizó Dennis
Ritchie sobre un computador DEC PDP-11 con sistema operativo UNIX. C es el
resultado de un proceso de desarrollo que comenzó con un lenguaje anterior, el BCPL,
el cual influyó en el desarrollo por parte de Ken Thompson de un lenguaje llamado B,
el cual es el antecedente directo del lenguaje C. El lenguaje C es un lenguaje para
programadores en el sentido de que proporciona una gran flexibilidad de programación
y una muy baja comprobación de incorrecciones, de forma que el lenguaje deja bajo la
responsabilidad del programador acciones que otros lenguajes realizan por sí mismos.

Desde su creación, surgieron distintas versiones de C, que incluían unas u otras

características, palabras reservadas, entre otras. Este hecho provocó la necesidad de
unificar el lenguaje C, y es por ello que surgió un standard de C, llamado ANSI-C, que
declara una serie de características, etc., que debe cumplir todo lenguaje C. Por ello, y
dado que todo programa que se desarrolle siguiendo el standard ANSI de C será
fácilmente portable de un modelo de ordenador a otro modelo de ordenador, y de igual
forma de un modelo de compilador a otro.

 Estructura de un programa en Lenguaje C

Un programa en C es simplemente un fichero de caracteres que contiene un conjunto

de instrucciones que un programa especial, el compilador o traductor, se encarga de
transformar en un código que la computadora puede ejecutar (código objeto). En
general, un programa suele estar compuesto de tres partes:

 El encabezamiento, que especifica las declaraciones globales de los datos

y sus tipos, que vamos a manejar a lo largo del programa;
 La función principal, que se suele llamar main, y define la estructura del
programa.
  Las funciones o subrutinas auxiliares, que realizan las operaciones
necesarias; son llamadas por la rutina principal, la función main. Se suelen
colocar después de esta función.

Cuando la envergadura del programa es grande se suele fragmentar el programa en

varias partes, incluyendo cada parte en un fichero separado. Normalmente se coloca en
cada fichero todas las subrutinas y funciones que se encarguen de una tarea del
programa. Por tanto, un programa C puede estar formado por diferentes módulos o
fuentes. Es conveniente mantener los módulos de un tamaño no muy grande, para que
la compilación sea rápida.
 También, al dividirse un programa en partes, se puede facilitar la legibilidad del
programa y su estructuración. Los diferentes módulos son compilados de forma
separada -únicamente los módulos que han sido modificados desde la última
compilación-, y después enlazados o combinados entre ellos y con las bibliotecas
necesarias para formar el programa en su versión ejecutable, mediante un programa
denominado enlazador (linker).

 Directivas de compilación

La compilación de un programa C se realiza en varias fases que normalmente son

automatizadas y ocultadas por los entornos de desarrollo:

 Preprocesado: consiste en modificar el código en C según una serie de

directivas de preprocesador.
 Compilación: que genera el código objeto a partir del código ya
preprocesado.
 Enlazado: que une los códigos objeto de los distintos módulos y bibliotecas
externas (como las bibliotecas del sistema) para generar el programa
ejecutable final.

Para una compilación, estos procesos se realizan uno a continuación de otros:

primero se realiza el preprocesado mediante el cual el propio código es modificado y
expandido mediante el agregado de líneas de código (proveniente de otros archivos);
luego el código resultante es compilado y finalmente enlazado (“linkeado”).

Las directivas que pueden darse al preprocesador son, entre otras:

 include para la inclusión de archivos

 define para la definición de macros
 ## es un operador
 # if se usa para inclusiones condicionales
  Declaraciones globales y locales

En C todas las variables han de ser declaradas antes de ser utilizadas. Las variables
pueden declararse en tres sitios diferentes:

 Dentro de las funciones (variables locales).

 Fuera de todas las funciones (variables globales).
 En la definición de los parámetros de las funciones.

La declaración tiene el siguiente formato:

<clase><tipo><iden>[=<exp>][,<iden>[=<exp>][...]];

Lo que está colocado entre corchetes [...] indica opcionalidad.

 La <clase> determina la forma de almacenamiento de la variable, que

determina su visibilidad y su existencia (auto o local, extern o global, static
o estática, y register o registro).

 El <tipo> determina el tipo de dato que almacena la variable.

 En <iden> se declara un identificador que opcionalmente puede ser
inicializado al valor de <exp>; se pueden declarar más identificadores
separados por comas, pudiendo llevar cada uno su propia inicialización.
  El = sirve para inicializar las variables dentro de la declaración de tipo. Para
hacer esto la declaración debe consistir en un tipo de datos, seguido por un
nombre de variable, un signo (=) y una constante del tipo apropiado. Al final
se debe poner, como de costumbre, un punto y coma (;). Por tanto, la
primera vez que nos aparezca dicha variable, si no ha sido asignada
posteriormente a su declaración de tipo, tomará el valor que le hemos dado
en dicha declaración.

La visibilidad de una variable va a depender del sitio en el que se ha declarado. En

función de esto tenemos:

 Variables locales: Las variables que se declaran dentro de un bloque de

sentencias se denominan variables locales. Estas variables se crean al
comienzo del bloque y se destruyen al salir del bloque al que pertenecen.

 Variables globales: una variable es global cuando se declara fuera de todos

los bloques. Las variables globales se conocen a lo largo de todo el
programa y se pueden utilizar desde cualquier sitio. Todas las funciones y
bloques declarados después de una variable global, podrán acceder a ella.
Si dentro de un bloque se repite la declaración de una variable definida en
un bloque exterior, el acceso se referirá exclusivamente a la variable dentro
del bloque más interno. Es decir, el nombre de un bloque externo es válido
a menos que un bloque interno lo vuelva a definir.

 Comandos básicos del Lenguaje C

Los comandos necesarios para compilar, enlazar los diferentes módulos y ejecutar
un programa dependen del sistema operativo, por lo que el programador debe dirigirse
a los manuales correspondientes para conocer la sintaxis exacta. Como forma más
común se puede dar la siguiente:
  compilar: cc prog, cc modulo1, modulo2
 enlazar: link prog, modulo1, modulo2
 ejecutar: prog

 Tipos de variables y constantes

1. Tipos de variables

Deben declararse antes de utilizarse y en ese momento se “crean” en la memoria,

son accesibles por su nombre. Pueden ser:

 Externas (globales): se definen sólo una vez, fuera de toda función y se

declaran extern (implícita o explícitamente) en cada función que las vaya a
utilizar, siendo comunes a todas. Son inicializadas a 0 por omisión.
  Internas (locales): son declaradas dentro de una función y solo existen en
ellas. No tienen una inicialización por omisión y quedan indefinidas en su
valor inicial si no se las inicializa explícitamente.

Además, pueden ser:

 Estáticas: son visibles sólo dentro del archivo fuente (externas) o función
(internas) en donde se declaran. Las estáticas internas mantienen su valor
en sucesivos llamados a la función. Son inicializadas a 0 por omisión. Se
deben inicializar con un valor o una expresión constante.
 Register: le indica al compilador que la variable será muy usada. El
compilador decidirá si será almacenada en un registro. No poseen
inicialización por omisión.

2. Constantes

En C, las constantes se refieren a los valores fijos que el programa no puede alterar;
algunos ejemplos de constantes de C son:

Existen, además, algunos tipos de constantes, distintos a los anteriores, que es

necesario resaltar de forma particular. Estos tipos de constantes son las constantes
hexadecimales y octales, las constantes de cadena, y las constantes de barra invertida.
 Las constantes hexadecimales y octales son constantes enteras, pero definidas en
base 16 (constantes hexadecimales) o en base 8 (constantes octales). Las constantes de
tipo hexadecimal comienzan por los caracteres 0xseguidas del número deseado. Las
constantes de tipo octal comienzan por un cero (0). Por ejemplo, son constantes
hexadecimales 0x34 (52 decimal), 0xFFFF (65535 decimal); y constantes octales 011(9
decimal), 0173 (123 decimal).

Las constantes de cadena son conjuntos de caracteres que se encierran entrecomillas

dobles. Por ejemplo, son constantes de cadena “Esto es una constante de cadena”,
“Estos son unos apuntes de C”, etc.

Las constantes de caracteres de barra invertida se usan para introducir

caracteres que es imposible introducir por el teclado (tales como retorno de carro, etc.;
estas constantes son proporcionadas por C para que sea posible introducir dichos
caracteres como constantes en los programas en los cuales sea necesario. Estas
constantes de caracteres de barra invertida son:
 Utilización de operadores para la formación de expresiones

 Operadores aritméticos

El lenguaje admite los siguientes operadores aritméticos:

Que devuelven un valor acorde a la operación realizada.

 Operadores relacionales
 Devuelven 1 (verdadero) o 0 (falso) según corresponda. Por otro lado, en C,
cualquier valor distinto de cero equivale a “verdadero”.

 Operadores de acceso a datos y elementos de array

 Operadores lógicos

 Expresiones

Una Expresión es una combinación de variables y/o constantes, y operadores. La

expresión es equivalente al resultado que proporciona al aplicar sus operadores a sus
operandos. Por ejemplo 1 + 5 es una expresión formada por dos operandos (1 y 5) y el
operador (el +); esta expresión es equivalente al valor 6, por lo cual quiere decir que
allí donde esta expresión aparece en el programa, en el momento de la ejecución es
evaluada y sustituida por su resultado. Una expresión puede estar formada por otras
expresiones más sencillas, y puede contener paréntesis de varios niveles agrupando
distintos términos.

En C, existen diferentes tipos de expresiones. El cual depende del tipo de operadores

que se estén utilizando. Se debe recalcar que, si existen algunas expresiones encerradas
entre paréntesis, estas se evalúan primero. Si existen expresiones en paréntesis anidadas,
es decir, que uno se encuentra dentro de otros paréntesis, se evalúan los más internos.

 Declaración de variables y constantes

1. Declaración de Variables

En C, las variables pueden se deben declarar antes de emplearse, ya se ha

mencionado con anterioridad como se realiza. En el siguiente cuadro se muestras
algunas declaraciones:
 2. Declaración de Constantes

Las constantes, como su nombre lo indica, son valores que se mantiene invariables
durante la ejecución del programa. Su formato es el siguiente:

const tipo_de_dato nombre= valor;

Donde const, es una palabra reservada, para indicarle al compilador que se está
declarando una constante.

Ejemplo:

 const int dia=7;

 const tipo_de_dato nombre= valor;
 const float pi=3.14159;
 const char caracter= ‘m’;
 const char fecha[]=”25 de diciembre”;

Caso Especial Constantes Simbólicas

Las constantes simbólicas, se declaran mediante la directiva #define. Funcionan de

la siguiente manera, cuando C, encuentra el símbolo que representa a la constante, lo
sustituye por su respectivo valor.

Ejemplo:

 #define N 150
 #define PI 3.1416

Existen algunas diferencias fundamentales entre la declaratoria const y #define; la

primera const, va dentro del programa, es decir, dentro de la función main() o alguna
función definida por el usuario, mientras que #define va en el encabezado, después de
los #include, por eso estas no llevan al final el punto y coma (;).
  Las funciones como unidades lógicas o bloques para efectuar tareas dentro
de un programa

Una función es un bloque de código dentro del programa que se encarga de realizar
una tarea determinada. Por lo tanto, un programa en C debe constar de una o más
funciones, y no puede faltar la función principal main(). Cuando se tiene un programa
que es bastante complicado; se puede separar en pequeños subprogramas (funciones),
para lograr la solución por separados de cada uno de ellos, y así resolver el problema
mayor en numerosos problemas más pequeños.

Si un programa, está constituido por más de una función, las llamadas a la misma,
pueden realizarse desde cualquier parte del programa, y la definición de ellas debe ser
independiente unas de otras. Por lo tanto, sería un grave error el tratar de definir una
función dentro de otra. Una función puede ser llamada desde cualquier parte del
programa no sólo una vez, y cuando es llamada, empieza a ejecutar las acciones que
están escritas en código.

 Entrada de datos desde el teclado o cualquier dispositivo

Para el correcto funcionamiento de la entrada y salida en C, dado que las funciones

de E/S, estructuras de datos usadas por esas funciones, etc., se encuentran declaradas
en el archivo de cabecera <stdio.h>, es necesario incluir dicho archivo, mediante la
directiva del preprocesador #include, para que la E/S funcione correctamente, pues en
caso contrario, puede funcionar de forma incorrecta, e incluso, puede llegar a dar
errores de compilación.

1. Entrada desde teclado

Se refiere a las operaciones que se producen en el teclado, dicho dispositivo es

automáticamente abierto y cerrado al comenzar y terminar el programa, por lo cual, no
debe ser abierto ni cerrado por el propio programa. Existen, básicamente, tres funciones
de entrada.
 La función getchar(), lee un carácter desde el teclado. Dicha función se define
como:
int getchar(void);
Dicha función lee caracteres, de uno en uno, desde el teclado, esperando, para
leer los caracteres, la pulsación de un retorno de carro. Es por ello que es posible
escribir varios caracteres antes de que ninguno de ellos sea leído. La función
getchar() hace eco en pantalla del carácter leído. En caso de error devuelve EOF.

 La función gets() lee un string desde el teclado. La función se define como:

char *gets(char *s);
La función gets() lee un string desde el teclado hasta que se pulsa un retorno de
carro. El string es almacenado en la variable s, y el retorno de carro leído desde
el teclado es, automáticamente, reemplazado por un carácter de final de string
('\0'). Devuelve un puntero a la variable s si sucede de forma correcta, y NULL
en caso contrario. La función gets() permite corregir errores de teclado usando
la tecla de retroceso antes de pulsar el retorno de carro.

 La función scanf() se usa para leer cualquier tipo de dato predefinido desde el
teclado, y convertirlo, de forma automática, al formato interno adecuado. La
función se define como:
int scanf(const char *formato[,dirección,...]);
El string formato es la cadena de control que indica los datos a leer. Dicha
cadena de control consta de tres clases de caracteres:
 Especificadores de formato.
 Caracteres de espacio en blanco.
 Caracteres que no sean espacios en blanco.
Los especificadores de formato están precedidos por el signo %, y dicen a la
función que tipo de datos van a ser leídos a continuación. Los especificadores
de formato validos son:

Además, es posible utilizar los modificadores h (short), l (long) y L. El

modificador h se puede aplicar a los tipo d, i, o, u y x, e indica que el tipo de
dato es short int o unsigned short int según el caso. El modificador l se puede
aplicar a los casos anteriores, indicando que el tipo de dato es long int o
unsigned long int, pero, además, se puede aplicar a los tipos e, f y g, indicando,
en tal caso, que el tipo de dato es double. Por último, el modificador L se puede
aplicar a los tipos e, f y g, e indica que el tipo de dato es long double.

Los caracteres de espacio en blanco en la cadena de control dan lugar a que

scanf() lea y salte sobre cualquier número (incluido cero) de espacios en blanco.
Un espacio en blanco es, además del carácter espacio, un tabulador o un salto
de línea. Un carácter que no sea espacio en blanco da lugar a que scanf() lea y
elimine el carácter asociado. Por ejemplo, %d:%d da lugar a que scanf() lea
primero un int, después lea, y descarte, los dos puntos, y luego lea otro int. Si
el carácter especificado no se encuentra, scanf() termina su ejecución.
 Todas las variables utilizadas para recibir valores (si son necesarias), deben ser
pasadas por "referencia", o sea, por sus direcciones. Esto supone que los
argumentos deben ser punteros a las variables. La presencia del signo * después
del signo % y antes del código del formato produce que scanf() lea, pero no
asigne el valor leído a ninguna variable. Por ejemplo:

int x,y;
scanf("%d%*c%d",&x,&y);

Provoca que, si la entrada es 10/20, se le asigne el valor 10 a la variable x, se

lea, y se descarte el signo /, y después se asigne el valor 20 a la variable y. La
función scanf() devuelve un número igual al de campos que han sido asignados
correctamente, este número no incluye los campos que fueron leídos, pero no
asignados, utilizando el modificador * para eliminar la asignación. En caso de
error de vuelve EOF.

2. Funciones de entrada y salida mediante puertos

 3. Funciones de entrada y salida de la unidad de disco

 Escritura de programas en Lenguaje C

Un mismo programa en C se puede escribir de varias formas. Todas ellas pueden

ser compiladas correctamente por el compilador y obtener un ejecutable, pero algunas
de ellas son más fáciles de entender por las personas que otras. Cuando un programa
está compuesto por varios cientos de miles de líneas, o incluso varios millones, es muy
importante escribir el código tal que sea muy sencillo de leer. De lo contrario, se
necesita una enorme cantidad de esfuerzo (quien dice esfuerzo dice dinero) para hacer
cualquier modificación, por simple que parezca.

También hay que entender que el código normalmente se escribe una vez, pero se
lee decenas de veces: para buscar problemas, para entender cómo funciona antes de
modificarlo, o para escribir otros módulos que interactúan con él. La norma no escrita
que se sigue en la industria es que el código lo va a estar leyendo constantemente gente
que no participó en su escritura. A continuación, se describen las reglas a respetar.

1. Nombres de las variables

 Los nombres de variables, funciones y ficheros deben ser cortos,
descriptivos y concretos.

 Los nombres de variables y funciones deben escribirse en minúsculas y, si

se componen de varias palabras, cada palabra debe separarse mediante el
símbolo “_” (guión bajo). Hay otras tendencias tales como usar
mayúsculas para separar palabras (estilo que se conoce como
“CamelCase”).

 Las macros y constantes deben escribirse en mayúsculas para distinguirlas

de variables y funciones.

 Las constantes y enumerados públicos deben llevar un prefijo corto de 3 o

4 letras que identifique al módulo que los define (un módulo es un
 conjunto de datos y funciones contenidos en varios ficheros). Esto evita
conflicto de nombres entre distintos módulos.

2. Formato del código

 El código se debe indentar para representar la estructura lógica del

programa. Deben usarse tabuladores para indentar, nunca espacios. La
indentación que se adopta en el curso es de 4 espacios en blanco. Te
recomendamos configurar el editor de código para que el tabulador
introduzca el equivalente a 4 espacios.

 El motivo de usar tabuladores en lugar de espacios es que, de esta forma,

cada desarrollador puede visualizar el código con el nivel de indentación
que más cómodo le resulte. Sólo hay que configurar el editor para
representar el tabulador con el nivel de profundidad que se desee.

 Las llaves deben colocarse según el estándar Allman, también conocido

como BSD, es decir, en la línea siguiente a un if, o a un while.

 Debe haber un espacio en blanco antes y después de los operadores de

comparación, asignación, etc. También debe haber un espacio entre las
palabras clave (for, while, if, return, etc.) y las expresiones que le siguen.

 El contenido de las funciones debe caber entero en pantalla. No debería

ser necesario hacer scroll para ver el contenido completo, aunque en
ocasiones puede ser necesario extenderse. En cualquier caso, nunca se
deben escribir funciones que excedan el espacio de dos pantallas.
 Las líneas no deben tener una longitud mayor a 80 letras. Este convenio
facilita la visualización de varios ficheros simultáneamente en la pantalla.
3. Uso del pre-procesador

 Deben usarse macros para definir tamaños de arrays de forma que sean
fáciles de leer y modificar. Es frecuente usar las macros también para otro
tipo de constantes en el código. En el caso de arrays, el motivo es simple:
en origen, C no permite usar variables para dimensionar un array. La única
manera de usar constantes simbólicas con ellos es usar el preprocesador.

4. Comentarios en el código

 Todas las funciones definidas en un fichero “.c”, ya sean públicas o

privadas (static) deben llevar un comentario encima que diga en una línea
o dos qué es lo que hacen. También se pueden añadir en este encabezado
comentarios sobre particularidades del funcionamiento general de la
función.
Estos comentarios son para que una persona que esté explorando el código
pueda entender qué hace una función sin tener que estudiarla en
profundidad. Este breve comentario en el encabezado de la función debe
apoyarse a su vez en un nombre de función descriptivo.

 Deben añadirse comentarios a partes no triviales del código. En muy raras

ocasiones es necesario comentar líneas individuales, pues si el código está
bien escrito, no es necesario repetir en un comentario lo que ya está escrito
en C.
5. Organización del código

 El código en C se organiza en ficheros con extensiones “.c” y “.h”. Para

cada fichero “.c” debe existir un “.h” con el mismo nombre (list.c, list.h).
A esta pareja de ficheros se la denomina informalmente módulo. Los
ficheros “.c” no son únicamente un conjunto de funciones. La clave para
organizar el código en varios ficheros y no tener problemas de
dependencias cruzadas (el compilador protesta porque desconoce un
símbolo o definición que está en otro fichero), es entender que lo que en
otros lenguajes de programación se maneja de manera natural como
objetos, en C suelen ser los módulos (aunque muchísimo más simplificado,
claro).

 Cada módulo (u “objeto” si se quiere) tiene un conjunto de funciones

cuyos prototipos conforman la interfaz pública que está definida en el
fichero “.h”. El fichero “.c” contiene la implementación de estas funciones
y en algunos casos variables y funciones que sólo son accesible dentro del
“.c”. Los prototipos de las funciones que se consideran públicas (se pueden
utilizar desde cualquier otro sitio del programa) se ponen en el “.h” para
que otros módulos puedan usarlas utilizando al comienzo de su fichero la
directiva #include. Las otras funciones, las privadas, se incluyen sólo
dentro del “.c” definidas con el prefijo static y así no pueden ser invocadas
desde otro fichero.

 Cada fichero “.c” debe tener al comienzo una directiva include para incluir
a su propio “.h” (por ejemplo, list.c debe tener #include "list.h"). Esto se
hace para evitar inconsistencias entre la definición de variables o
prototipos de las funciones públicas en el “.c”, y la declaración de su
 prototipo en el “.h”. Si se incluye el “.h” en su correspondiente “.c”, el
compilador puede detectar conflictos de tipo.

 Los ficheros “.h” deben contener sólo declaraciones públicas: tipos,

constantes, variables globales y prototipos de funciones diseñados para ser
usados desde fuera del módulo. Todo lo demás se debe incluir en el “.c”

 Todo fichero “.h” debe contener una guarda para evitar inclusiones
múltiples. Una guarda se implementa rodeando el contenido del fichero
entero entre #ifndef SÍMBOLO y #endif. El nombre del símbolo debe ser
único para ese fichero (se recomienda utilizar el propio nombre del fichero
con guiones bajos). A continuación de la primera línea que tiene el #ifndef
debe ir la directiva #define seguida del mismo símbolo idéntico que se ha
incluido en la línea anterior. Tras esta directiva se incluye el contenido del
fichero “.h” con normalidad.

 Los ficheros “.h” sólo deben contener las directivas #include

imprescindibles para compilar por sí mismos.

 Es obligatorio definir como static las variables y funciones privadas (que

no pueden usarse en ningún otro sitio). Las variables globales de un
módulo, deben definirse juntas al comienzo del fichero para poder
identificarlas de un vistazo. En ningún caso deben estar desperdigadas por
el medio del fichero. Una consecuencia de esta regla es que conviene
separar la definición de estructuras de la declaración de variables globales
de tipo struct. Por un lado, se definen los tipos (si son públicos en el “.h”,
si no lo son en el “.c”), y por otro se declaran las variables globales del
módulo haciendo uso de esos tipos.
  Definición y uso de las funciones gráficas

Las funciones gráficas como su nombre lo indica son aquellas funciones

relacionadas a los gráficos.
Funciones generales de gráficos
  Ejemplo de las estructuras de un programa en Lenguaje C

1. Estructuras Secuenciales

Se les denomina así, porque son estructuras en un programa, que después de ejecutar
una instrucción o sentencia, continúan con la otra, hasta llegar al final del programa.

Ejemplos

 Diseño de un programa que calcula el cuadrado y el cubo de tres números

introducidos por el usuario.

#include <stdio.h>

#include <conio.h>

main()

{
int x, x1, x2, y, y1, y2, z, z1, z2;

clrscr();

printf("\tPROGRAMA QUE CALCULA EL CUADRADO Y EL CUBO DE 3

NUMEROS\n\n");

printf("Introduzaca el primer n£mero:\n");

scanf("%d", &x);

printf("Ahora ingrese el siguiente n£mero:\n");

scanf("%d", &y);

printf("Y el tercer n£mero es:\n");

scanf("%d", &z);

x1=x*x;

x2=x*x*x;

y1=y*y;

y2=y*y*y;

z1=z*z;

z2=z*z*z;

printf("*********************************\n");

printf("**Numero****Cuadrado*****Cubo****\n");

printf("**%d **** %d ***** %d ****\n", x, x1, x2);

printf("**%d **** %d ***** %d ****\n", y, y1, y2);

printf("**%d **** %d ***** %d ****\n", z, z1, z2);

printf("*********************************\n");

getch();

return 0;

 Una empresa necesita conocer el sueldo neto a pagar a un empleado.

Teniendo como entrada el salario produzca una salida de sueldo neto. Los
descuentos a aplicar son: ISSS 5%, AFP 7% y Renta 10%, estos descuentos
son sobre el salario, y es sueldo neto es la diferencia entre el salario y el
total de las retenciones:

#include <stdio.h>

#include <conio.h>

main()

float sueldo, afp, isss, renta, sn;

char nombre[50];

clrscr();

printf("Introduzca el Nombre del empleado:\n");

scanf("%s", nombre);

printf("Su sueldo es:\n");

scanf("%f", &sueldo);
afp=sueldo*0.07;

isss=sueldo*0.05;

renta=sueldo*0.10;

sn=sueldo-(afp+isss+renta);

printf("El empleado %s\n", nombre);

printf("Posee un sueldo neto de %.2f\n", sn);

getch();

return 0;

2. Estructuras Selectivas

Para ello C, dispone de tres tipos de 3 tipos de estructuras selectivas, la cuales son:

a) Estructura Selectiva Simple

Funciona de la siguiente manera: se evalúa una condición, de ser cierta efectúa una
acción, de lo contrario, continúa con la ejecución normal del programa.

Su sintaxis es la siguiente:

If(condición) Acción;

O también:

If(Condición)

Acción;

Donde:
  Condición: Es una expresión lógica que es evaluada por el compilador
 Acción: es la Acción o Acciones que realizará el programa de resultar cierta la
condición

En C, no existe la sentencia “End If”, como en otros lenguajes de programación para

indicar que ha terminado el bloque de selección, sino que este se especifica con el punto
y coma al final. Además, que después de la condición NO se escribe un punto y coma.
Si son varias acciones, estas deben ir dentro de llaves {}, para indicarle al compilador
que son un solo bloque de acciones que deben ejecutarse.

Ejemplo

 Diseño de un programa en C, que a partir del importe total de la compra

muestre lo que debe pagar el cliente, de una tienda se venden artículos de
primera necesidad, a los cuales se les aplica un descuento del 20%, de la
compra total, si esta es igual o mayor a $50.

#include <stdio.h>

#include <conio.h>

main()

float compra;

clrscr();

printf("Introduzca el valor de la compra:\n");

scanf("%f", &compra);

if(compra>=50)
 compra=compra*0.8;

printf("El Importe de la compra es %.2f\n\n", compra);

getch();

return 0;

b) Estructura selectiva doble

Esta estructura, se caracteriza por el hecho que ofrece dos caminos a seguir,
dependiendo si al evaluar la condición resulta cierta o falsa. Su sintaxis es la siguiente:

if(Condición)

Acción 1;

else

Acción 2;

Funciona, de la siguiente manera si la condición, al evaluarla resulta cierta, realiza

la acción 1. de lo contrario, es decir; si al evaluar la condición resulta falsa, realiza la
acción 2. Se debe tener en cuenta la condición puede ser compuesta, es decir haciendo
uso de los operadores && y || (Y lógico y No lógico), además que cuando tenemos más
de una sentencia por ejecutar ya sea del lado del cierto o del falso, estas van dentro de
llaves.
Ejemplo

 Se desea saber si un número es par o impar. Diseñe un programa en el cual

el usuario, ingrese el número y el programa muestre con un mensaje, si éste
es par o no.

#include <stdio.h>

#include <conio.h>

main()

int num;

printf("Ingrese el n£mero:\n");

scanf("%d", &num);

if(num%2==0)

printf("ES PAR\n\n");

else

printf("ES IMPAR\n\n");

getch();

return 0;

}
 c) Selección múltiple

Como su nombre lo indica, permite seleccionar entre varios caminos para llegar al
final. En este caso se pueden elegir un camino o acción a ejecutar de entre varios
posibles que se debe de evaluar, llamada selector. Sintaxis:

switch(selector)

case Etiqueta A:

Acción A;

break;

case Etiqueta B:

Acción B;

break;

case Etiqueta n:

Acción n;

break;

default:

Excepción;

break;

}
 En donde:

 Selector: Variables, expresiones simples de tipo ordinal, (enteros y caracteres

–int y char-)
 Etiqueta: Tiene que ser del mismo tipo de datos de selecto. Estas deber ser
constantes únicas y diferentes de otras.
 Excepción: Es opcional.

Ejemplo

 Diseño de un programa en C, que dado un número del 1 al 3, muestre en

pantalla y en letras, el mismo número:

#include <stdio.h>

#include <conio.h>

main()

int n;

clrscr();

printf("El N£mero es:\n");

scanf("%d", &n);

switch(n)

case 0: puts("Cero");

break;
 case 1: puts("Uno");

break;

case 2: puts("Dos");

break;

case 3: puts("Tres");

break;

default: puts("Dato No valido");

break;

getch();

return 0;