lenguaje de programación c

Facultad de Ingeniería, UNAM

Laboratorio de Multimedia e Internet

Laboratorio de Multimedia e Internet, Facultad de Ingeniería. UNAM 2009-2010

Lenguaje de programación C

Objetivo:

Que el alumno conozca y aprenda a utilizar el lenguaje C, desde sintaxis, variables, preprocesador,

funciones, apuntadores, estructuras.

Historia de C:

El lenguaje C es un lenguaje de propósito general y se caracteriza por:

1. Programación estructurada o por módulos

2. Abundancia de operadores y tipos de datos

3. Codificación en alto y bajo nivel simultáneamente

4. Utilización natural de las funciones primitivas del sistema

5. Produce código objeto altamente optimizado

6. Es fácil de aprender

7. El programador es la principal figura ya que lo que pida si su sintaxis es correcta se hace

El lenguaje C está basado en BCPL, escrito por Martin Richards, y del B escrito por Ken

Thompson en 1970 para el primer sistema UNIX. Estos son lenguajes sin tipos, al contrario que el

C que proporciona varios tipos de datos. Los tipos que ofrece son caracteres, números enteros y

en coma flotante, de varios tamaños. Además se pueden crear tipos derivados mediante la

utilización de punteros, vectores, registros y uniones.

El primer compilador de C fue escrito por Dennis Ritchie para un DEC PDP-11 y escribió el

propio sistema operativo en C.

En 1983 ANSI establece el comité X3J11 para que desarrolle una definición moderna y

comprensible del C; el estándar está basado en el manual de referencia original de 1972 y se

desarrolla con el mismo espíritu de sus creadores originales. La primera versión de estándar se

publicó en 1988 y actualmente todos los compiladores utilizan la nueva definición. Una aportación

muy importante de ANSI consiste en la definición de un conjunto de librerías que acompañan al

compilador y de las funciones contenidas en ellas. Muchas de las operaciones comunes con el

sistema operativo se realizan a través de estas funciones. Una colección de ficheros de

encabezamiento, headers, en los que se definen los tipos de datos y funciones incluidas en cada

librería. Los programas que utilizan estas bibliotecas para interactuar con el sistema operativo

obtendrán un comportamiento equivalente en otro sistema.


Estructura Básica de un programa en C:

Lo inicial para un programa es colocar el “main” así como las llaves que limitan al programa esta es

la parte más importante de este.

Cuidar mucho que llave que se abre inmediatamente cerrarla.

main ( )

{

.......

}

Ahora como ya comentamos el lenguaje C está orientado a lo que es la programación de

funciones lo cual veremos más adelante ahora otro dato importante dentro de la estructura de un

programa ya un poco más en forma seria de la siguiente manera:

Librerías: es un conjunto de recursos (algoritmos) prefabricados, que pueden ser utilizados por

el programador para realizar determinadas operaciones, Las declaraciones de las funciones

utilizadas en estas librerías, junto con algunas macros y constantes predefinidas que facilitan su

utilización, se agrupan en ficheros de nombres conocidos que suelen encontrarse en sitios

predefinidos.

Librerías de C:

‹assert.h› La librería assert o en español aserción, contiene operaciones para detectar errores de

lógica y depuración.

‹complex.h› Esta librería complex contiene un conjunto de funciones dedicadas al tratamiento de

números complejos.

‹ctype.h› Esta librería posee funciones para el tratamiento de cadenas alfanuméricas.

‹errno.h› Verifica los códigos de error devueltos por las funciones de cada librería.

‹fenv.h›Esta librería se dedica a controlar números en coma flotante.

‹float.h› Con esta librería se modifica y controla características para la librería de coma flotante.

‹inttypes.h› Conversión entre variables y constantes de precisión entre tipos de números

enteros.

‹iso646.h› Conjuntos de caracteres ISO 646.

‹limits.h› Propiedades de los números de tipo enteros, contiene las constantes para modificar sus

parámetros.


‹locale.h› Básicamente se utiliza para la función que contiene, setlocale() y sus constantes. Con

esta se realiza la configuración regional.

‹math.h› Esta librería contiene funciones matemáticas.

‹setjmp.h› Con esta librería se declara las macros setjmp y longjmp para saltos de flujo de

control de programa no locales.

‹signal.h› Esta librería está dedicada a controlar algunas situaciones poco comunes como la

división por cero.

‹stdarg.h› Posibilita el acceso a una cantidad variable de argumentos pasados a una función.

‹stdbool.h› Álgebra de Boole.

‹stdint.h› Define varios tipos de variables enteras.

‹stddef.h› Define varios tipos de macros de utilidad.

‹stdio.h› Esta función tal vez la más utilizada, sirve para operaciones de entrada y salida mediante

los diferentes puertos, entrada/salida del lenguaje C, entre las funciones más comunes printf y

scanf.

‹stdlib.h› Dentro de las finalidades de esta librería podemos encontrar conversión de tipos,

generación de números pseudo-aleatorios, gestión de memoria dinámica, control de procesos,

funciones de entorno, de ordenación y búsqueda.

‹string.h› Esta librería sirve para el manejo de cadenas de caracteres alfanuméricos.

‹tgmath.h› Esta librería contiene funcionalidades matemáticas de tipo genérico.

‹time.h› Manejo de formatos y conversiones de fecha y hora.

‹wchar.h› Controla y maneja el flujo de datos grandes y varias clases de cadenas de caracteres

anchos las cuales suelen ser mayores a 2 o más bytes por cada carácter, sirve para controlar

caracteres de idiomas diferentes.

‹wctype.h› Esta librería está destinada a clasificar caracteres anchos.

De todas las librerías anteriores las más comunes son stdio.h, stlib.h y math.h

/***Comentarios del programa a realizar***/

#include <stdio.h> /*declaración de funciones C standar de entrada y salida*/

#include< libreria.h> /*otras librerías necesarias para el funcionamiento del

programa*/

#define ALGO valor /*declaración de constantes*/


funcionDentroDelProg(); /*declaración de funciones que se utilizaran dentro del

programa*/

En donde se declara esta función antes o después del main no importa pero si la tienes que

mandar llamar antes de que se ejecute el programa

main() /*declaración de la función principal del programa*/{

int a,b,c; /*declaración de variables locales del programa*/

/*cuerpo del programa en general*/

}

Ahora bien va a haber muchos programas donde no es necesario el tener varias funciones y

estarlas llamando pero para una buena programación y poder reutilizar códigos es bueno separar

pedazos de acciones del sistema.

Checar el programa anexo “1prograCurso.c” posible tarea es manipular ese código para

que quede centrado, cambiar el lema, etc.

Vamos a analizar cada parte del programa por separado:

Directrices del procesador: su finalidad es facilitar el desarrollo, compilación y el

mantenimiento de un programa. Se caracterizan porque empiezan con el carácter # como

son #include o #define estas lo que hacen es ser procesadas por el preprocesador de C

que trabaja al momento de mandarlo compilar el programa y crear un ejecutable.

Definiciones y declaraciones: en estas son como las subrutinas que habíamos platicado con

anterioridad y estas al estar separadas pueden ser reutilizadas más adelante en otros

programas y es importante que antes de que corra el programa sean llamadas ya que de

no hacerlo ocurriría un error al no saber cómo sería posible trabajar, posteriormente se

desarrolla el proceso como cualquier programa con main pero al final queda bien

especificado con la palabra reservada “return” que va a devolver como resultado esta

función. Pero este puede regresar o no ciertos valores su sintaxis cuando regresa y

admite datos (ejemplos de paso por argumentos) es la siguiente:

nombreDeLaFuncion(tipoDato NombreDeVariable)


Su sintaxis es igual que la de las funciones main pero con el extra de que al ser llamada por

la función principal se le llama como fue declarada y al final se le coloca un “;”

Función main: esta función seria como la portada de un libro y es en esta parte donde

todo se va a tratar, manipular, etc. etc., y el desarrollo de la función esta ya visto que va

encerrado entre llaves.

◦ Manipulación de datos para subrutinas o funciones dentro de main: en la declaración

de funciones también dentro de los argumentos su sintaxis va a ser la siguiente:

tipoDeResultadoaRegresar nombreFuncion (lista de parámetros con su tipo);

Esto es de suma importancia ya que sobre esta plantilla vamos a trabajar lo que

sería pasar argumentos a función.

◦ Paso de argumentos por función: primero que nada al tener ya definida la subrutina (si

recibe datos desde afuera o no) podemos pasar por argumento lo que sería de forma

de parámetro (miFuncion (int x, float y)) y meter directamente los valores

programándolo o ya dentro de la subrutina hacer una igualdad y manipular lo que

serian las copias de estos datos:

Esto realiza una copia pero no cambia los valores iníciales de x e Y.

int x;

float y;

miFuncion()

{

a=x;

b=y;

...

return(0);

}

Revisar el programa 6progC.c para ver ejemplo de lo de arriba

◦ Paso por referencia: esto realiza una función similar a la de paso por argumento pero

con la diferencia que aquí si se alteran los contenidos originales ya que lo que ocurre


en esta ocasión es que en la función se pasa la dirección de cada argumento y no el

contenido del mismo.

Como pudimos ver existen dos formas de declarar una función (implícita main(), explicita int

main(int) ), para el caso de la implícita C por omisión supone una función como int para el

resultado forzando a que el valor de retorno sea del mismo tipo ocasionando un error común

dentro de la programación y es por ello que ponemos al final el return(0) y dependiendo el

sistema operativo donde se compilen los programas es el error que nos marcara que falta un valor

de retorno y generalmente son enteros ya que como trabaja en lenguaje binario (0,1) siendo 0 la

opción de que se ejecuto bien el programa y 1 que tuvo errores.

Esto es algo parecido a los apuntadores que veremos más adelante.

Revisar el programa 6progC2.c para ver ejemplo de lo de arriba

Tipos de Datos:

Dentro de nuestro lenguaje de programación van a existir varios tipos de datos básicos como son:

Tipos enteros:

◦ Char (carácter tamaño=1 byte): este tipo de dato se utiliza para almacenar un valor

entero del rango -128 a 127 donde los valores del 0 al 127 son valores a un carácter

del código ASCII

◦ Short (entero de formato corto tamaño=2 bytes): este tipo de dato proporciona un

entero en el rango de los valores -215 a (215 -1)

◦ Int ( entero tamaño=2 o 4 bytes): este tipo de dato es un numero sin punto decimal y

su tamaño varía dependiendo del procesador de la maquina (16, o 32 bits)

◦ Long ( entero de formato largo tamaño=4 u 8 bytes): este tipo de dato trabaja igual

que el shor o int pero con la condición que es para números muy grandes

◦ Enum: este tipo de dato trata de una lista de valores que pueden ser tomados como

una variable de ese tipo y se utilizaran con un identificador algo similar a una

estructura

Tipos reales:

◦ Float (reales de precisión simple tamaño=4 bytes): estos datos contienen números con

punto decimal y está comprendido en un rango de -1.7976E+38 a -2.22507E-38 para

negativos y de 1.175494E-38 a 3.402823E+38 para números positivos cuidando que

solo tenga hasta 7 cifras después del punto decimal

◦ Double (reales de precisión doble tamaño=8 bytes): este tipo de dato trabaja de la

misma forma que el float pero tiene un rango más extendido de -1.7976E+308 a -


2.22507E-308 para números negativos y de 1.175494E-38 a 3.402823E+38 para

números positivos. Este tipo de dato puede contener hasta 16digitos después del

punto decimal

◦ Long Double (reales de precisión doble formato largo tamaño=10 bytes): Estos datos

son igualmente derivados de los float pero con un rango mayor así como las cifras

significativas después del punto decimal para este caso son 19 y comprende de -

1.189731E+4932 a -3.362103E-4932 para números negativos y 3.362103E-4932 a

1.189731E+4932 para números positivos

Otros:

◦ Void: este tipo de dato específica que es un conjunto vacio de valores no se ocupa

para declarar variables como cualquiera de los anteriores pero indica que:

▪ la función no acepta argumentos

▪ declara funciones las cuales no regresan ningún valor

▪ declarar un apuntador genérico.

Constantes:

Este tipo de datos son fijados previamente por el programador antes de compilar el programa y

nunca cambian durante la ejecución del mismo; estos tipos de datos pueden ser de cualquier tipo

(real, entero, carácter, etc.) su sintaxis es:

#define NombreDeTuConstante ValorComportamiento

Existen distintos tipos de datos como float así como entero ya que con esto la computadora al

compilar y ver los tipos de datos declarados que son de cierto tamaño ya les da la memoria

suficiente con la cual va a estar trabajando el ejecutable y esto ayuda a que los recursos de la

computadora si se están utilizando en varias aplicaciones no tenga un problema de pantalla azul.

Actualmente por la capacidad de las maquinas ya se pueden trabajar muy fácilmente este tipo de

programas pero cuando apenas iniciaba este tipo de implementaciones si consumía sino toda la

memoria gran parte de ella.

Variables:

Estas son los tipos de datos que más se trabajan en la programación y se declaran de la siguiente

forma:

tipodeDato variableCualquiera;

int x, y, z; /*aquí son 3 variables distintas pero todas son enteros*/

char aux;

Para inicializar una variable solo basta con hacer una igualdad después de hacer su

declaración o incluso antes de utilizarla como veremos más adelante ejemplo:


int x=12, y=0, z;

z=345;

Variables Globales: existe y tiene un valor desde el inicio hasta el final de la ejecución del

programa y son del mismo carácter global todas las funciones

Variables Locales estas existen y tienen un valor desde el momento de ser declarados

hasta que termina el bloque donde fue declarado

Checar y explicar el programa 6progC2.c y explicar las variables locales y globales

Identificadores:

Esto nos indica que son como vamos a llamar a las funciones o subrutinas de nuestro programa y

en lenguaje C toma como cosas distintas lo que es mayúsculas de minúsculas y solamente acepta

letras y números:

No se puede empezar un identificador con números ni puedes dejar espacios en blanco

Suma, SumaPares, Conversion_celsiosAfarenheit, sintonia1

Palabras reservadas:

Estas palabras son identificadores preestablecidos para el lenguaje C y nunca los podemos ocupar

estos son los siguientes:

Auto double int struct

break else long switch

Case enum register typedef

Char extern return union

const float short unsigned

continue for signed void

default goto sizeof volatile

Do if static while

Comentarios:


Estos son de mucha ayuda cuando se está trabajando con distintas personas en un mismo

programa y así poder ir documentando que se realiza en cada paso o que es lo que se pretendía

hacer y se pueden colocar en cualquier parte del programa; su sintaxis es:

/* Espacio para poner comentario */

También existen otros tipos de datos pero estos parten de los ya mencionados exceptuando lo

que serian estructuras, apuntadores, y funciones que veremos a profundidad más adelante en el

curso.

Con el programa 2progC.c poner de tarea que manipulen varias cosas como son las cadenas

y varios cambios tomando como base este programa.

Funciones de librería:

Putchar: esta función es similar al printf pero solo trabaja para oraciones y no puede meter

argumentos como son los datos y su sintaxis es

putchar('cualquier cosa como el primer ejemplo de printf');

putchar(variablecualquiera);

Printf: esta función escribe en pantalla series de caracteres, valores, etc. pero dependiendo

de su sintaxis es lo que mostrara en pantalla:

printf(“Escribir dentro de las comillas y sale tal cual en pantalla”);

printf(“%especificaion de formato”, variable donde se guarda el valor);

C identifica un carácter en base a una comparación dentro de sus registros ya que para cada tecla o

combinación de teclas tiene asignado un numero ya sea en hexadecimal o binario con el cual compara y si

esta dentro del rango de los registros validos los acepta y guarda esto basado en la tabla de caracteres

ASCII

Scanf: esta función recibe y guarda datos dentro de variables previamente identificadas (int,

char, float, etc.) cuidando la sintaxis como sigue:

scanf(“%especificaion de formato”,&variable donde se guardara);

Getch o Getchar: esta función es similar al scanf pero con la diferencia que solamente

admite un carácter introducido por el teclado sin mostrarlo nuevamente en la pantalla,

comúnmente esta función le da una pausa al programa para que nos deje visualizar el

resultado del programa.

getch();


Especificadores de formato para printf y scanf:

d, i (int) Enteros con signo, decimal

U (int) Enteros sin signo, decimal

O (int) Entero sin signo, octal

X,x (int) Enteros sin signo, hexadecimal

f, e, E, g, G (double) valores con signo con hasta 6 cifras decimales

C Un solo carácter

S Cadena de caracteres terminada con el símbolo \0

N Apuntador a un entero y almacena el dato en el buffer

P Puntero apuntado a void

Secuencias de escape de C:

\n Salto de línea y regresa al inicio de la misma

\t Tabulador horizontal

\v Tabulador vertical (solo para las impresoras)

\b Retroceso (backspace)

\r Retorno de carro pero sin saltar de línea

\f Alimentación de pagina (solo impresoras)

\a Alerta, pitido

\' Comilla simple

\” Comilla doble

\\ Barra invertida (backlash)

\ddd Caracter ASCII de forma octal

\xdd Caracter ASCII de forma hexadecimal

Operadores:

Estos son símbolos que indican cómo se van a manipular los datos y los dividiremos en:


Aritméticos: Estos operadores son utilizados al realizar operaciones matemáticas y son

los siguientes:

+ Suma, aplicable a enteros y reales

- Resta, aplicable a enteros y reales

* Multiplicación, aplicable a enteros y reales

/ División, aplicable a enteros y reales pero solo dividiendo dos reales el resultado da otro real

en otros casos siempre da un real

% Modulo o resto de una división entera, aplicable solo a operadores enteros.

Lógicos: Este operador solamente trabaja con las operaciones AND, OR NOT

devolviendo siempre un valor verdadero o falso (0,1) y son:

&& AND. Da como resultado un valor lógico 1 si ambos operandos son distintos a 0 si uno de

ellos es 0 devuelve siempre un 0

|| OR. El resultado es 0 cuando los dos operandos dan igual a cero

! NOT. Regresa como resultado el contrario del operando 0->1 y 1->0

◦ Lógicos para manejo de Bits: Para manejo de bits podemos realizar operaciones AND,

OR, XOR y desplazamientos bit por bit de los operandos.

& Operación AND a nivel de bits

| Operación OR a nivel de bits

^ Operación XOR a nivel de bits

<< Desplazamiento a la izquierda

>> Desplazamiento a la derecha

Relación: El resultado de las operaciones de relación nos da un valor verdadero o falso

(1,0)

< Primer operando menor que el segundo

> Primer operando mayor que el segundo

<= Primer operando menor o igual que el segundo

>= Primer operando mayor o igual que el segundo

!= Primer operando distinto que el segundo

= = Primer operando igual que el segundo


Asignación: para estos operadores el resultado de una operación de asignación es el valor

de almacenado en el operando izquierdo, lógicamente después de que la asignación se ha

realizado y este valor es convertido al tipo de dato del operando de la izquierda:

++ Incremento

-- Decremento

= Asignación simple

*= Multiplicación mas asignación

/= División mas asignación

%= Modulo mas asignación

+= Suma más asignación

-= Resta mas asignación

<<= Desplazamiento a izquierda mas asignación

>>= Desplazamiento a derecha más asignación

&= Operación AND sobre bits mas asignación

|= Operación OR sobre bits mas asignación

^= Operación XOR sobre bits mas asignación

Dirección-de: el operador & (dirección-de) da la dirección de su operando:

int a=7; /*a tiene el valor 7 y lo veremos el valor y su dirección de memoria*/

printf(“dirección de memoria=%d, Dato=%d”, &a, a);

Checar el programa 7progC.c para ver cómo funciona este operador

Indirección: este tipo de operador va muy ligado a lo que es apuntadores, y es * y lo que

realiza es guardar en una variable la dirección de memoria de un dato, y al mandarlo llamar

devuelve directamente el dato no la dirección de donde está. (se retomara con más

ejemplos al ver los apuntadores)

Sizeof: este operador nos devuelve lo que sería el tamaño en bytes de su operando, se

utiliza principalmente en el manejo de memoria dinámica

Prioridad y orden de evaluación de operadores

( ) [] . -> sizeof Izquierda a derecha


- ~ ! * & ++ -- (tipo) Derecha a izquierda

* / % Izquierda a derecha

+ - Izquierda a derecha

<< >> Izquierda a derecha

< <= > >= Izquierda a derecha

== != Izquierda a derecha

& Izquierda a derecha

^ Izquierda a derecha

| Izquierda a derecha

&& Izquierda a derecha

|| Izquierda a derecha

?: Derecha a izquierda

= *= /= %= += -= <<= >>= &= |= ^= Derecha a izquierda

, Izquierda a derecha

Conversión de Tipos:

Este tipo de situación es muy frecuente cuando dentro de las subrutinas al estar trabajando con

variables de distintos tipos y regresarlas a la función original los necesitamos en otro tipo de dato

y para realizar estos cambios con los puros operadores se rige por las siguientes reglas:

1. Si un operando es de tipo double, el otro es convertido a double.

2. Si un operando es de tipo float, el otro es convertido a float.

3. Si un operando es de tipo unsigned long, el otro es convertido a unsigned long.

4. Si un operando es de tipo long, el otro es convertido a long.

5. Si un operando es de tipo unsigned, el otro es convertido a unsigned.

6. Si no, los operandos son de tipo int.

Pero también es posible realizar estas conversiones pero de manera explícita siguiendo la sintaxis:

(tipodedato a comportarse) variableAcambiar;

float a, c;

int b;

c=a+(float)b;

Checar el programa 6progC.c con el que se realiza un cast de entero a float


Sentencias de control:

Dentro del ámbito de la programación como ya vimos un poco en lo que son diagramas de flujo

podemos apreciar varios tipos de secuencias con las cuales vamos a modelar ya dentro de un

programa pero primero vamos a definir a cada tipo de sentencia y son:

Secuencia: Ejecución sucesiva de una o más operaciones.

Selección: Se realiza una u otra operación, dependiendo de una condición.

Iteración: Repetición de una o varias operaciones mientras se cumpla una condición.

Dicho esto analizaremos cada uno con su sintaxis y un ejemplo:

Sentencia if (selección): esta es muy sencilla y como su nombre lo dice va a realizar cierta

acción al cumplirse una condición

◦ sintaxis pseudocódigo:

if (expresión o condición)

sentencia

◦ sintaxis en C:


{

sentencia 1;

sentencia 2;


sentencia n;

}

Sentencia if-else (selección):esta sentencia trabaja exactamente igual que la if anterior pero

con la única diferencia que al encontrar otra respuesta distinta a la de la condición realiza

otro proceso:



sentencia 1

else

sentencia 2

◦ sintaxis en C:

if (expresión)

{

sentencia 1;


sentencia 2;

sentencia n;

}

else

{

sentencia 1;

sentencia 2;

sentencia n;

}

Checar el programa 3progC_IF.c como ejemplo

Sentencia switch (selección): en esta sentencia dependiendo de la expresión o condición

dada lo que va a realizar lo va a tener delimitado en ciertos casos dentro de los cuales

contempla todos los posibles así como uno para cualquier cosa no considerada:

Ejemplificar que tipo de expresiones o condiciones son aceptadas, porque solo acepta números o

letras(ASCII code)


Las expresiones que acepta como condiciones de los case solo pueden ser números enteros o

letras ya que dentro de la compilación del programa al comparar el código ASCII de cada una de

las expresiones de condición las conforma de manera más sencilla.


switch (expresión o condición)

caso expresión 1:

sentencia1

break

caso expresión 2:

sentencia 2

break

caso expresión n:

sentencia n

break

default:

sentencia default

◦ sintaxis en C:

switch (expresión o condición)

{

caso expresión 1:

sentencia 1;

break;

caso expresión 2:

sentencia 2;

break;

caso expresión n:


sentencia n;

break;

default:

sentencia default;

}

Al termino de cada caso se pone un break con lo cual se termina la instrucción de ese

bloque de no colocarlo entra en un ciclo infinito y comete error

La sentencia break se verá más a fondo adelante junto con continue.

La checar el programa 4progC_CASE.c como ejemplo

Sentencia for (ciclo): en esta sentencia se delimitan un inicio, una condición y cuanto va a

estar aumentando en cada vuelta la variable de inicio; para que con esto mientras se

cumpla la condición se repite el proceso a su término continua con las demás

instrucciones del programa:



for(variable inicio; expresión o condición; aumento de variable inicio)

sentencia

◦ sintaxis en C:

for (variable inicio; expresion;aumento de variable inicio)

{

sentencia 1;

sentencia 2;

sentencia n;

}

La checar el programa 8progC_FOR.c como ejemplo

Sentencia while (ciclo): esta sentencia trabaja de forma similar al for pero con la diferencia

que en la expresión no se manejan tanta sintaxis sino mas bien su sintaxis en la expresión

es similar al if y el aumento de la variable contador se hace dentro del cuerpo del while:



while (expresión o condición)

sentencia

◦ sintaxis en C:

while (expresión)

{

sentencia 1;

sentencia 2;

sentencia n;

aumento o decremento de expresión;

}

La checar el programa 9progC_WHILE.ccomo ejemplo

Sentencia do-while (ciclo): esta sentencia realiza exactamente lo mismo que la while pero

con la única diferencia que esta sentencia valida o invalida la expresión después de haber

corrido una sola vez las sentencias del ciclo:



do

sentencia;

while (expresión o condición)

◦ sintaxis en C

do

{

sentencia 1;

sentencia 2;

sentencia n;

} while (expresión);

Se pueden ir combinando cada una de las sentencias de expresión que es lo que se llama

anidamiento con lo cual vas a seguir haciendo ciclos o secuencias para lo cual ahí que checar todo

lo que es sintaxis y cerrar cada una de las llaves de cada sentencia de control

Sentencia break: esta sentencia se utiliza para terminar una sentencia de ciclo como puede

ser las switch, while, do o for. Ves que se coloca no importa que este anidada una


sentencia dentro de la otra ya que esta sentencia termina solo el ciclo en el cual este

contenido.

La checar el programa 13progC_BREAK.c como ejemplo

Sentencia continue: esta sentencia es similar a la de break pero esta no detiene la

sentencia de ciclo sino que limita gracias a una condición a donde va a seguir ejecutando

los ciclos, igualmente dentro de las iteraciones de ciclos termina y continua el ciclo donde

este contenido

La checar el programa 12progC_CONTINUE.c como ejemplo

Control de flujo:

Esta función es como un complemento con lo cual podemos ir teniendo una bitácora dentro de la

ejecución del programa ya que al término de cada ciclo, sentencia de control, subrutina, etc. que

nos regresa un cierto valor cuando todo lo que se tenía que ejecutar lo realiza de forma correcta.

Esto se logra colocando al final de cada subrutina la palabra “return” y entre paréntesis un valor o

expresión con lo cual podemos saber que se realizo de forma correcta.

La mayoría de los programas tienen ese return solo es cosa que le pongan atención

Construcción de tipos:

Los tipos de datos que ya estudiamos en capítulos anteriores lo único que se va a hacer es

mezclarlos para crear nuevos tipos vamos a manejar 3 principalmente:

1. Arrays

2. Estructuras

3. Uniones

1. Array: Un array es una colección ordenada de elementos de un mismo tipo de

datos, agrupados de forma consecutiva en memoria. Cada elemento del array tiene

asociado un índice, que no es más que un número natural que lo identifica

inequívocamente y permite al programador acceder a él.

Su definición es muy sencilla es similar a una variable cualquiera pero con un cierto tamaño:


tipodeDato nombreDeArray[tamañoDelArray];

int índice[20]; /*esto es un array de tamaño 20 que guarda datos

enteros*/

char nombreAlu[20];/*este es un array que guarda 19 caracteres y un

terminador de cadena*/

Ahora para obtener, guardar y manipular los datos contenidos en un array primero tenemos que

declarar el array, posteriormente darle que capture el dato con las funciones scanf y en el espacio

donde declaramos donde va a guardar ese dato colocamos el índice donde queremos guardarlo

como si fuese una variable completamente distinta:

int índice[20];

printf(“dame un valor:”);

scanf(“%d”,&indice[0]); /*guarda el valor ingresado en la posición 0 de

índice*/

índice[4]=índice[0] ; /*iguala el valor de índice 0 y lo coloca en 4*/

printf(“el valor ingresado es: %d y su copia es %d”, índice[0], índice[4]);

Vectores: Este tipo de datos funcionara solo para datos numéricos para lo cual vamos a trabajarlo

de la misma forma que hacemos un vector en Algebra. Su sintaxis es la siguiente:

tipodeDato nombreDeVector [tamañofilas][tamañocolumnas];

int miVector[2][2]; /*Esto nos da un vector de dimensión 2x2*/

Este tipo de arreglo lo vamos a poder acceder de la misma forma que un array y para seguir

metiendo datos tendríamos que hacerlo línea por línea o mandar ciclos for para cada uno de los

llenados de fila.


Checar los programas 10progC_ARRAY.c y 10progC_ARRAY2.c como ejemplos

2. Estructuras: es un tipo de datos compuesto que agrupa un conjunto de tipos de

datos (no necesariamente iguales) en un único tipo, se utiliza principalmente en lo que

serian datos de una misma cosa pero en distintas aéreas.

Para definir una estructura se hace de la siguiente forma:

struct nombreEstructura /*Aquí con la palabra reservada struct definirá*/

{ /*una nueva variable de variables o estructura*/

declaración de variable1; /*campos a cubrir*/

declaración de variable2;

.

declaración de variableN;

}; /*NOTA aquí la estructura se delimita con un ;*/

/*ya que es otra variable*/

Una vez definida esta estructura podremos declarar variables de ese tipo, de la siguiente forma:

struct nombreEstructura nombreVariable;

A partir de este momento la variable nombreVariable contendrá información acerca de cada uno

de los campos definidos en la estructura. Algo similar a que dentro de este nuevo tipo de variable

vamos a declarar otra que trabaje exactamente igual que la estructura declarada anteriormente.

Ahora para poder ingresar datos específicos dentro de esta nueva estructura vamos a guardarlo

con un operador y sintaxis un poco distinta de la siguiente forma.


nombreVariable.campo1=10; /*aquí dentro de la estructura se considera que campo1 es un dato de tipo

entero*/

nombreVariable.campo2= nombreVariable.campo1 * 3.1415; /*aquí asigna también el valor al campo2

por medio de una multiplicación y lo guarda en un campo2 que sería tipo float*/

Ya por ultimo para mandar llamar algún dato en especifico de la estructura se hace igual que antes

con un % tipoDato y al terminar comillas se hace alusión a lo que estamos llamando en este caso

el campo de la estructura colocándolo de forma igual a lo que sería para asignar valores junto con

un punto

Checar el programa 11progC_STRUCT.c como ejemplo

3. Uniones: este tipo de dato es muy similar a lo que serian las estructuras pero con la

diferencia que los datos ingresados son uno a uno y se va perdiendo la información al

meter nuevos datos. Es por esta razón que solo lo mencionaremos en el curso y no

iremos más allá en el tema ya que no son prácticos.


Apuntadores:

Dentro de C, cada variable de un programa tiene una dirección en la memoria del ordenador. Esta

dirección indica la posición del primer byte que la variable ocupa. En el caso de una estructura es la

dirección del primer campo. Actualmente en las computadoras la dirección de inicio se considera la

dirección baja de memoria. Como en cualquier caso las variables son almacenadas ordenadamente

y de una forma predecible, es posible acceder a estas y manipularlas mediante otras variables que

contenga su dirección. A este tipo de variables se les denomina punteros o apuntadores.

Una ventaja que obtenemos de los punteros es la posibilidad que nos dan de poder tratar con

datos de un tamaño arbitrario sin tener que moverlos por la memoria. Esto puede ahorrar un

tiempo de computación (ciclo de reloj) muy importante en algunos tipos de aplicaciones. También

permiten que una función reciba y cambie el valor de una variable. Recordemos que todas las

funciones C únicamente aceptan parámetros por valor. Mediante un puntero a una variable

podemos modificarla indirectamente desde una función cualquiera.

Su forma de ser declarado es:

tipodeDato *nombreDeVariable;

float *apuntador;

Su manipulación como variable es de la siguiente forma:

Se utiliza su nombre; pero para acceder a la variable a la que apunta se le debe preceder de *.

Accedemos indirectamente a una variable. Para trabajar con punteros existe un operador, &, que

indica 'dirección de'. Con él se puede asignar a un puntero la dirección de una variable, o pasar

como parámetro a una función.


Existe también lo que sería un apuntador de apuntadores el cual es un vector en el cual cada una

de las casillas del vector guarda un apuntador y este guarda una dirección de cierta variable:

int (*pvector) [2], *p1, *p2; /*aquí estamos creando un vector de apuntadores*/

/*así como 2 apuntadores comunes*/

El colocar el vector de apuntadores con paréntesis es simple organización ya que no son

muy necesarios

Checar 14progC_APUNTADOR.c como ejemplo

Manejo de archivos:

Dentro del ámbito de la programación en C en diversas ocasiones vamos a necesitar guardar los

resultados de algún programa pero esto no es fácil ya que el programa una vez terminado de

correr sale de la pantalla y ya no puedes guardar la información. A menos claro que

introduzcamos varios comandos que veremos a continuación con los cuales vamos a poder abrir,

manipular, salvar, cargar, leer, etc.

Ahora es importante aclarar que para el manejo de archivos siempre lo vamos a realizar por

medio de apuntadores y la manejaremos con la palabra reservada FILE.


Fopen: Esta función abre y crea archivos en el Disco y va a tener dos parámetros al

escribir su sintaxis:

1. Nombre: esto será una cadena de caracteres que contenga el nombre de un archivo

valido (existente) y esto puede ser por nombre de tipo dirección relativa o absoluta

Una dirección relativa es el puro nombre del archivo y su extensión (apuntesC.doc,

southpark.jpg, etc.) y la dirección absoluta es toda la ruta de acceso para ese archivo

(c:\Users\Desktop\apuntes.c, c:\Users\Desktop\southpark.jpg)

2. Modo: esto especifica el tipo de archivo que va a abrir o creara y el tipo de datos que

puede contener, (texto o binario)

Sintaxis:

FILE *fopen(char *nombre, char *modo);

FILE *fopen(char *datosAlumnos, char *r);

r El archivo existe, solo lectura

w Abre archivo para escritura, si existe lo sobrescribe sino lo crea

a Añade y abre para escritura situando el cursor al final, sino existe lo crea

r+ El archivo existe, lectura y escritura

w+ Abre archivo para leer y escribir, si existe lo sobrescribe sino lo crea

a+ Añade y abre para escritura y lectura situando el cursor al final, sino existe lo crea

t Tipo de texto

b Tipo binario


Si no se especifica la t o la b el programa se asume como que es de texto

Fclose: Con esta función se va a poder cerrar o finalizar el uso de archivos y guardando la

información que se le haya hecho

Sintaxis:

int fclose(FILE *archivo);

Fgetc: Esta función permite leer un carácter desde un archivo, si no encuentra nada en el

archivo nos va a devolver como respuesta EOF

Sintaxis:

int fgetc(FILE *fichero);

int fgetc(FILE *sueldosEmp);

El EOF significa que es el terminador de cadena con esto el programa sabe dónde termina

una cadena de caracteres EOF= End Of File

Fputc: Esta función es como lo contrario de fgetc ya que esta introduce un carácter en el

archivo

Sintaxis:

int fputc(int caracter, FILE *fichero);

int fputc(int R, FILE *Pruebas);

Feof: Esta función nos proporciona la información si se ha alcanzado el final de un archivo,

principalmente se ocupa como comparación para seguir leyendo datos del archivo, si nos

regresa un valor distinto a 0 significa que no ha terminado.

Sintaxis:

int feof(FILE *fichero);

int feof(FILE *ListasCurso);

Rewind: esta regresa el cursor al inicio del archivo de almacenado

Sintaxis:


void rewind(FILE *fichero);

void rewind(FILE *ListasCurso);

Fgets: Esta función está diseñada para leer cadenas de caracteres, donde leerá hasta n-1

caracteres o hasta que lea un regreso de línea, donde n va a ser el número de elementos a

entrar

Sintaxis:

char *fgets(char *cadena, int n, FILE *fichero);

char *fgets(char *cadena, int 20, FILE *ListasCurso);

Fputs: esta función escribe una cadena en un archivo, pero sin el carácter EOF ni el

carácter de retorno de línea

Sintaxis:

int fputs(const char *cadena, FILE *stream) ;

Fread: con esta función se trabajan registros de longitud constante, leyendo desde un

archivo uno o varios registros de la misma longitud y a partir de una dirección de memoria

determinada El usuario es responsable de que asegurarse de que exista espacio suficiente.

Sintaxis:

size_t fread(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);

size_t fread(void *puntero, size_t 30, size_t 12, FILE *ListaCurso);

Fwrite: esta función escribe dentro de un archivo uno o varios registros de la misma

longitud almacenados a partir de una dirección de memoria determinada.

Sintaxis:

size_t fwrite(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);

size_t fwrite(void *puntero, size_t 30, size_t 12, FILE *ListaCurso);

Fprintf: esta función es exactamente igual que la ya trabajada antes de printf pero con la

diferencia que esta trabaja con archivos

Sintaxis:

int fprintf (FILE *fichero, const char *formato, ...);

int fprintf (FILE *ListaCurso, 10 char *formato, ...);


Fscanf: esta función es exactamente igual que la ya trabajada antes de scanf pero con la

diferencia que esta trabaja con archivos

Sintaxis:

int fscanf (FILE *fichero, const char *formato, ...);

int fscanf (FILE *ListasCurso, 10 char *formato, ...);

Fflush: esta función borra el contenido dentro del buffer y cuando se llena de datos los

mete al archivo especificado en el programa y hace esto repetidas ocasiones (similar a

cuando dejamos de escribir en office y se guarda solito el documento)

Sintaxis:

int fflush (FILE *fichero);

int fflush (FILE *ListaCurso);

Funciones Especificas de Ficheros

◦ Fseek: esta función sitúa el cursor del archivo a leer o escribir en un lugar deseado,

regresa un cero si la función tuvo éxito y un valor distinto a cero si hubo algún error.

Cabe denotar quien en origen podemos colocar :

1. SEEK_SET: donde contara el desplazamiento desde el inicio del archivo

2. SEEK_CUR: donde contara el desplazamiento desde la posición actual del cursor

3. SEEK_END: donde contara el desplazamiento desde el final del archivo

Sintaxis:

int fseek (FILE *fichero, long int desplazamiento, int origen);

int fseek (FILE *ListaCurso, long int 477, int 0);

◦ Ftell: esta función sirve para que la computadora nos proporcione la posición actual

del cursor, regresándonos la posición actual del cursor o un -1 si se produjo algún

error.

Sintaxis:

long int ftell (FILE *fichero);

long int ftell (FILE *ListaCurso);

Checar el programa 15progC_ARCHIVOS.c


Asignación Dinámica de Memoria:

Dentro del ámbito de la programación ya digamos un poco más avanzada se introducen este tipo

de cuestiones en las cuales si vamos limitando cuánto va a almacenar una estructura y hasta el

momento lo único que conocemos es la asignación estática de memoria y en varias ocasiones para

que pueda seguir un algoritmo adelante necesita que se le metan un determinado número de datos

pero el dato a introducir o es muy corto o muy largo y al estar limitado por un cierto tamaño no

es posible utilizarlo con facilidad y es aquí cuando entran la asignación dinámica.

Asignación dinámica de memoria: es la asignación de memoria necesaria para almacenar un

objeto durante el tiempo de ejecución del programa.

En este sentido las variables locales están asociadas a asignaciones de memoria dinámicas,

puesto que se crean y destruyen durante la ejecución del programa.

Dentro de este tipo de manejo de memoria dinámica tenemos varias funciones:

Malloc: esta función nos permite asignar un bloque de memoria de nbytes consecutivos en

memoria para almacenar uno o más objetos de un tipo cualquiera; devuelve un puntero

genérico que da la referencia del espacio asignado

Realloc: esta función permite volver a cambiar el tamaño de un bloque de memoria

previamente asignado en la función malloc; devuelve un puntero genérico que da la

referencia del espacio reasignado

Calloc: esta función trabaja exactamente igual que la función malloc pero en este caso es

para asignar dinámicamente el tamaño de matrices

Free: esta función es sumamente importante ya que esta indica al cpu que se debe liberar

la memoria reservada por malloc, calloc, realloc.

Si no se pone un Free al término del programa donde se utilizan funciones de asignación

dinámica de memoria va haciendo más lenta la respuesta del CPU pues sigue usando siempre la

memoria y cuando se corre nuevamente el programa pide más y más memoria causando problema

de overflow


Tareas por asignar o Ejercicios

Inserte aquí las tareas o ejercicios a realizar por los estudiantes

Tarea 1

1. Crear un programa con el cual despliegue los datos del programador

2. Crear un programa con el que despliegue los datos del programador y del usuario que lo

visite

3. Basándote en las directivas de precompilamiento,

4. Hacer un programa que cambie un dato de int a float y viceversa y mostrarlo en pantalla

5. Hacer un programa que utilice un if-else

6. Hacer un programa que utilice un for

7. Hacer un programa que utilice un while

8. Hacer un programa que utilice un switch

9. Hacer un programa que utilice un array

10. Hacer un programa que utilice un struct

Tarea 2

1. Hacer un programa que según lo que quiera un usuario calcule el área de un triangulo, un

cuadrado o un circulo

2. Hacer un programa que convierta de grados Celsius a Fahrenheit y viceversa

3. Hacer 4 programas basándote en los diagramas de flujo que se pidieron como tarea en

capítulos anteriores (4 de todos los que se hicieron y especificara las opciones en clase)

4. Hacer un programa que calcule 5 valores recibiendo solamente 2 que meta el usuario

(suma, multiplicación, modulo, cuadrado de un numero, un número elevado al segundo

numero ingresado)

5. Hacer un programa que con el uso de archivos guarde los datos en un de una persona y

que al abrir el .txt guarde todos los registros que se ingresen sin perder los datos.

Control de Versión

Autor Fecha Versión

Autor

Ian

Priscilla (revisión)

Ian

dd-mm-aa

14-10-2009

//

16-10-2009

1.1

1.2

Revisión

2.0

lenguaje de programación c

Documents