Guia Lenguaje C icel

Fundamentos de Programación Profesor: Cristian Millacariz

GUIA DE LENGUAJE EN C


2 | P a g e

Índice:

Índice:.................................................................................................................................................. 2 Lenguaje C .............................................................................................................................................. 3

Introducción: ....................................................................................................................................... 3 CAPITULO I: “Características del Lenguaje C” ............................................................................... 4

CAPITULO II: “Variables en C” ....................................................................................................... 6 CAPITULO III: “Operadores en C” ................................................................................................... 8 CAPITULO IV: “Asignaciones y Expresiones en C” ........................................................................ 9

CAPITULO V: “E/S por consola con Formato” ............................................................................... 10 CAPITULO VI: “Sentencias de Control” ......................................................................................... 12 CAPITULO VII: “Iteraciones en C” ................................................................................................. 14

CAPITULO VIII: “Arreglos en C” ................................................................................................... 16 CAPITULO IX: “Funciones de caracteres y strings” ....................................................................... 17 CAPITULO X: “Funciones y Procedimientos” ................................................................................ 18

CAPITULO XI: “E/S en Archivos” .................................................................................................. 20 APENDICE A ................................................................................................................................... 22

FUNCIONES DE C .............................................................................................................................. 22 APENDICE B: .................................................................................................................................. 24


3 | P a g e

Lenguaje C

Introducción:

C es un lenguaje de programación de propósito general que ofrece como ventajas: economía de expresión, sentencias de control y estructuras de datos modernas junto a un rico conjunto de operadores. C es un lenguaje de nivel medio, ya que combina elementos de lenguaje de alto nivel con la funcionalidad del lenguaje ensamblador. El definir a C como lenguaje de nivel medio, no significa que sea menos potente, más difícil de usar o menos evolucionado que los lenguajes de alto nivel como PASCAL, COBOL o FORTRAN; tampoco significa que C sea similar al lenguaje ensamblador presentando al programador todos los problemas asociados a él. Una característica importante del lenguaje C, es que posee un código muy portable, siendo posible adaptar el software escrito para un tipo de computador en otro. Durante muchos años, el estándar de C fue la versión proporcionada por el Sistema Operativo Unix (System V), pero con la popularidad de los Microcomputadores aparecieron variadas implementaciones de C, altamente compatibles unas con otras. Debido a esto, en el año 1983 el American National Standars Institute (ANSI), estableció un comité para producir una “definición no ambigua del lenguaje C e independiente de la máquina”, el resultado final se obtuvo en 1990 con la definición del estándar ANSI de C. En resumen, podríamos decir que C ha demostrado ser un lenguaje agradable, expresivo, versátil para una amplia variedad de programas y fácil de aprender.


4 | P a g e

CAPITULO I: “Características del Lenguaje C”

La principal característica de un lenguaje estructurado, es la capacidad de seccionar y esconder del resto del programa las instrucciones e información para llevar a cabo alguna tarea. Una forma de lograrlo, es usando subrutinas que empleen variables locales (temporales), de manera que lo que ocurra en su interior no provoque efectos secundarios en otras partes del programa. En un lenguaje estructurado, el uso de GOTO puede estar prohibido o desaprobado, no siendo una forma normal de control, tal como lo es en BASIC o FORTRAN. En base a lo anterior, C se denomina lenguaje sencillamente estructurado, dado que no permite la creación de funciones dentro de funciones. Además, soporta varias construcciones de bucles (while, do while y for) que permiten al programador no usar GOTO.

Programación de Sistemas: Los programas de sistemas más comunes son: los Sistemas Operativos, Intérpretes, Editores, Compiladores, Programas de Ensamblado y otros. C permite la programación de sistemas, ya que permite la manipulación directa de bits, bytes, palabras y punteros. Compilador versus Intérprete Intérprete: Utilitario que toma un programa escrito en un lenguaje de alto nivel, en el cual va leyendo y ejecutando directamente cada línea del código fuente, sin generar código de máquina. Las ventajas de los intérpretes es que son fáciles de construir. Su problema es que son lentos y requieren la presencia del código fuente cada vez que se desee ejecutar el programa. Compilador: Utilitario que toma un programa escrito en un lenguaje de alto nivel y lo traduce a un programa en lenguaje de bajo nivel o código de máquina. El proceso de una compilación puede dividirse en dos etapas. En la primera se chequea correctitud de sintaxis y secuencia de las instrucciones, generando un archivo de código intermedio u objeto. En la segunda se toma este código objeto y se une a las rutinas del sistema que se haya indicado, generando el programa en su estado final de código ejecutable. C normalmente es compilado, sin embargo, han ganado popularidad los intérpretes de C, como ayudas en la depuración durante las etapas de desarrollo en un programa. TIPOS DE DATOS Un tipo de dato define un conjunto de valores que puede tener una variable junto con un conjunto de operaciones que se pueden realizar sobre esa variable. C tiene cinco tipos de datos básicos incorporados, entre ellos están los enteros, los caracteres y los reales. Además, C no es un lenguaje fuertemente tipificado como Pascal, ya que permite casi todas las conversiones entre tipos. Por ejemplo, los tipos entero y carácter pueden ser entremezclados en la mayoría de las expresiones, siendo de responsabilidad del programador la comprobación de la incompatibilidad de los tipos.


5 | P a g e

Palabras Claves: Una palabra clave es aquella que tiene un significado especial dentro del lenguaje, debido a esto, nunca deben ser usadas como nombres de variables o funciones. Las palabras claves de C están escritas en minúsculas, siendo 32 las definidas por el estándar ANSI de C:

auto double int struct

break else long switch

case enum register typedef

char extern return union

const float short unsigned

continue for signed void (sin valor)

default goto sizeof volatile

do if static while

En C, las mayúsculas son diferentes con las minúsculas, así: else es una palabra clave y ELSE no lo es. Forma de un Programa: Los programas en C consisten en una o más funciones. La única función que siempre debe estar presente es la denominada main(), ya que es la primera en ser llamada cuando comienza la ejecución del programa. La forma general de un programa en C es la siguiente: declaraciones globales funcion1() { variables locales sentencias } . . . funcionn() { variables locales sentencias } main() { variables locales sentencias } En código C bien escrito, main() debe esbozar lo que el programa hace, utilizando los nombres de las funciones f1(), f2(), f3(),...fn() definidas por el programador. Técnicamente main() no forma parte del lenguaje C, pero debe tratarse como si lo fuera. Por esta razón, no debe usarse como nombre para una variable, ya que se puede confundir al compilador. Biblioteca y Enlazado: Una biblioteca es una colección de funciones para llevar a cabo diversas tareas. La biblioteca estándar de C, no forma parte del lenguaje, pero sí es un entorno que proporciona declaraciones, funciones y macrodefiniciones. C no proporciona dentro de la definición real del lenguaje, métodos para llevar a cabo las operaciones de entrada/salida, debido a esto, la mayoría de los programas incluyen llamadas a variadas funciones contenidas en la biblioteca estándar del lenguaje C. Cuando se llama a una función que no es parte del programa que se ha escrito, C “recuerda” su nombre. Más tarde, el enlazador combina el código objeto producido al compilar el programa fuente,


6 | P a g e

con el código objeto de la función que se encuentra en la biblioteca estándar. Este proceso se llama enlazamiento. Compilación Separada: La mayoría de los programas cortos de C están enteramente contenidos en un archivo fuente. A medida que aumenta la longitud del programa, también lo hace el tiempo de compilación, por ello, C permite dividir un programa en varios archivos y compilar cada uno de ellos por separado. Una vez que todos han sido compilados se enlazan entre sí junto con las rutinas de la biblioteca para formar el código objeto completo; la ventaja de este método es que el cambio en el código de uno de los archivos no requiere de la recompilación del programa completo.

CAPITULO II: “Variables en C”

Los números son los datos fundamentales usados en computación, estos se representan internamente en forma binaria. Dependiendo de la cantidad de bits o bytes, es posible representar diferentes tipos de números. La forma de almacenar números es mediante el uso de variables, que corresponden a representaciones lógicas de un grupo de bytes. Formalmente, una variable tiene un tipo y un identificador. El tipo corresponde a una palabra reservada que indica la cantidad de bytes que se le asignan a la variable. El identificador es el nombre que se le asocia a la variable. Tipos: En C existen 5 tipos de datos: carácter, entero, coma flotante, coma flotante de doble precisión y sin valor.

Tipo Tamaño en bits Rango

Char 8 0 a 255

Int 16 -32768 a 32767

Float 32 -3.4E-38 a 3.4E+38

Double 64 -1.7E-308 a 1.7E+308

Void 0 sin valor

Los valores del tipo char se usan para guardar los valores definidos en el juego de caracteres ASCII; las variables de tipo int se usan para guardar cantidades enteras; las variables tipo float o double se usan para guardar números reales; el tipo void se usa para declarar explícitamente que una función no retorna valor o para declarar una función sin parámetros. C soporta varios tipos agregados, incluyendo las estructuras, las uniones, las enumeraciones y los tipos definidos por el programador. Los tipos de datos básicos pueden ser alterados con el uso de modificadores, estos hacen que el tipo base se ajuste más a las necesidades de cada momento. Los modificadores son: signed, unsigned, short y long, produciéndose las siguientes combinaciones:

Tipo Tamaño en bits Rango

Char 8 -128 a 127

Unsigned char 8 0 a 255

Signed char 16 -128 a 127

Int 16 -32768 a 32767

Unsigned Int 16 0 a 65535

Signed Int 16 -32768 a 32767

Short Int 16 -32768 a 32767

Long Int 32 -2147783648 a 2147483647

Float 32 -3.4E-38 a 3.4E+38

Double 64 -1.7E-308 a 1.7E+308

Long Double 64 -1.7E-308 a 1.7E+308


7 | P a g e

Identificadores: Corresponden a los nombres usados para referirse a las variables, funciones , etiquetas y otros objetos definidos por el programador. La longitud de un identificador puede variar entre 1 y 32 caracteres. Para definirlos, se deben seguir las siguientes reglas:

Todo identificador debe empezar con una letra entre “a” y “z” o entre “A” y “Z” El resto del identificador pueden ser letras o dígitos del 0 al 9 o underscore (_). Otros símbolos

no pueden ser usados. Se consideran dígitos significativos sólo a los primeros 32. Los identificadores diferencian entre mayúsculas y minúsculas.

Ejemplos: Correcto Incorrecto inc 9inc nota nota? tot_ven tot..ven Declaración de Variables: Todas las variables deben ser declaradas antes de usarlas. La sintaxis para ello es:

Tipo lista_de_variables Donde tipo debe ser un tipo válido de C y lista_de_variables puede ser uno o más nombres de identificadores separados por comas. Ejemplos: int i,j,k;

float impuestos, IVA, calculo; char opcion, letra;

Inicialización: Es muy importante en el uso de variables el realizar una adecuada inicialización de las mismas, ya que al crearlas, éstas pueden tomar cualquier valor, lo que puede afectar el correcto funcionamiento del programa. La forma tradicional de inicialización en los lenguajes de programación es:

int contador; Contador = 0;

Sin embargo, en C es posible realizar dicha inicialización en el momento de la declaración de la variable:

int contador = 0, loop = -1; float IVA = 0.18;

Declaración de Constantes: Para definir constantes en C, se debe seguir la siguiente sintaxis:

#define identificador valor; Ejemplos:

#define maxlong 200; #define step 20;

Comentarios: Tal como en la mayoría de los lenguajes de programación, en C es posible indicar ciertas zonas como lugares donde no hay código y que es usado para realizar acotaciones sobre él. La práctica de comentar el código es muy útil, sobre todo si existe la posibilidad de futuras revisiones a los programas realizados. En C, las formas de indicar que cierto texto es comentario es encerrándolo entre /* y */ o comenzando la línea con //.


8 | P a g e

Ejemplos: a) /* Esta línea es comentario y no afecta la ejecución del programa */ int x=0; /* declaración e inicialización de la variable x */ b) // Este comentario sólo es válido hasta fin de línea

CAPITULO III: “Operadores en C” Definición: Un operador es un símbolo que le indica al compilador que lleve a cabo ciertas manipulaciones matemáticas o lógicas. En C, hay 3 clases generales de operadores: aritméticos, relacionales y lógicos. Operadores Aritméticos:

Acción Operador

Resta -

Suma +

Multiplicación *

División /

División en módulo %

Decremento --

Incremento ++

Ejemplos:

10/3 =3 10%3 =1 x++ x = x+1 y-- y = y-1 si x = 10 y = ++x x=11; y = 11(incrementa y asigna) y = x ++ y = 10; x = 11(asigna e incrementa)

Operadores Relacionales:

Acción Operador

Mayor >

Mayor o igual >=

Menor <

Menor o igual <=

igual ==

Distinto !=


9 | P a g e

Operadores Lógicos:

Acción Operador

And &&

Or ||

Not ! Precedencia: Es el orden en que se evalúan las expresiones.

1 ++ -- 2 * / % 3 + - 4 ! 5 > >= < >= 6 = = != 7 && 8 ||

Los operadores del mismo nivel de precedencia, son evaluados por el compilador de izquierda a derecha. Al utilizar paréntesis, se altera el orden de las evaluaciones, ejecutándose primero las operaciones que se encuentran dentro de ellos. Ejemplos: 10 > 1 +12 10 > (1+12) En ambos casos el resultado es falso (0) 10 > 5 && !(10 < 9) || 3 <= 4 Da como resultado Verdadero (1)

CAPITULO IV: “Asignaciones y Expresiones en C” Asignación: La asignación de valores a las variables definidas y el cómputo de operaciones aritméticas y/o lógicas, son las instrucciones básicas en C. variable = expresión ; Cada cómputo debe realizarse en una línea y al finalizar se debe colocar el carácter “;” lo que indica fin de la operación. Ejemplos: x = 200; y = x + 7; balance = (8 * x) + (4 / y); También es posible realizar operaciones lógicas y/o de comparación, teniendo presente que la variable de asignación toma valores de verdad. En C, los valores de verdad se representan como números enteros, cuyo valor es: 0 (FALSE), 1 (TRUE). Ejemplos: es_mayor = (x > y); (Si x=5 e y=2 entonces es_mayor toma el valor 1


10 | P a g e

pare = (i == 2) && (!ultimo) (notar que en esta expresión, la variable pare toma un valor de verdad, dependiendo de la evaluación de la expresión). Abreviaturas: C permite abreviaturas que simplifican la escritura de ciertos tipos de sentencias de asignación. La sintaxis es: Expresión operador = expresión; Ejemplos: x = x +10; x + = 10; x = x – 2; x - = 2;

x = x * (y + 1); x * = y + 1; En programas profesionales de C, la notación abreviada es muy usada, así que conviene familiarizarse con ella. Operador Coma: Produce una secuencia de operaciones, la parte izquierda del operador siempre se evalúa como void, y el valor asignado, es el valor de la última expresión de la lista separada por comas. La sintaxis es: Variable = (lista_de_expresiones); Ejemplos: y = 10; x = (y = y – 5, 25/y); Después de la ejecución x toma el valor 5.

CAPITULO V: “E/S por consola con Formato” Biblioteca Estándar: Las funciones de E/S por consola, se encuentran declaradas en el header <stdio.h> de la biblioteca estándar de C. Los header deben ser declarados antes de usar las funciones contenidas en él, la sintaxis para ello es: #include <header> printf() : Es una función que permite enviar a la pantalla (output estándar), caracteres con algún formato. Una orden de formato comienza con un signo de porcentaje y va seguido por el código del formato. Algunas órdenes de formato son:

Codigo Operación

%c carácter único

%d decimal (entero)

%ld decimal (entero largo)

%f decimal (punto flotante)

%s cadena de caracteres

%x dirección de memoria


11 | P a g e

Sintaxis: printf(“formato”, lista_variables); Ejemplos: Printf(“Hola %c %d %s”, ‘c’,10 , “qué tal!”); Imprime en pantalla Hola c 10 qué tal! Printf(“%6.2f”, 228.3415); Imprime 228.34 printf(“%10s”, “hola”); Imprime 6 blancos y hola printf(“%-10s”, “hola”); Imprime hola y 6 blancos En ambos casos se imprime el string hola, con la diferencia que el signo “-“ hace que se ajuste de izquierda a derecha. Printf(“%5.7s”, “1234567890”); Imprime 1234567 (Imprime el string 1234567, bajo el concepto de al menos 5 caracteres con un máximo de 7). Barra Invertida: Algunos códigos de barra invertida son:

Código Operación

\b Espacio atrás

\f Salto pagina

\n Salto línea

\t Tabulación horizontal

\v Tabulación vertical

\r Retorno de Carro scanf() : Es una función que permite leer la entrada de caracteres desde el teclado (input estándar), siguiendo algún formato. Los códigos de los formatos son similares al de la función printf(). Ejemplos:

scanf(“%d”,&numero); (Lee el entero ingresado asignándolo a la variable numero)

scanf(“Sr. %s %s”, nombre, apellido); (Descarta la entrada Sr. y asigna los caracteres correspondientes a las variables nombre y apellido). scanf(“%[A-Z]”,s1); (Acepta sólo caracteres entre “A” y la “Z”, y se lo asigna a la variable s1).


12 | P a g e

CAPITULO VI: “Sentencias de Control” Sentencia: Es una asignación o expresión, pero, terminadas con un “;” Ejemplos: x = 1; y = (y-3,4*4);

--j; Bloque: Es un grupo de sentencias que se encuentran entre “{“ y “}”. Ejemplos: { int x; x = 0; x + = 3; } Después de la llave que termina un bloque ”}” no se debe colocar “;” , a menos que vaya otra instrucción a continuación. Sentencia if-else : En C, la forma general de la sentencia if es: if expresión_logica bloque_de_sentencias [else bloque_de_sentencias ] y donde se tiene que: bloque_de_sentencias = sentencia; bloque_de_sentencias = {sentencia; [sentencia; ]} Ejemplos: if (a > b)

a = a +1; else b = b*10; Programa ejemplo: #include <stdio.h> /*Programa del número Mágico*/ main() { int magico = 50; int intento; printf(“Adivina un número: “); scanf(“%d”, &intento); if (intento == magico) printf(“¡¡¡¡¡Adivinaste!!!!!!”); else printf(“ Trata de nuevo........”); getch(); } Operador ? : Es una alternativa a la sentencia if/else en la forma general. La sintaxis de este operador es: Exp1 ? exp2 : exp3


13 | P a g e

Donde exp1, exp2 y exp3 son expresiones. Ejemplo: x = 10; y = x>9 ? 100 : 200 (Asigna a y el valor 100). La sentencia if/else equivalente es: x = 10; if (x>9) y = 100; else y = 200; Sentencia switch: En caso de tener una variable que puede tener múltiples valores, la forma cómo operar con cada uno de ellos puede ser mediante if anidados, o bien con la sentencia switch. switch(variable) { case valor1: bloque_de_sentencias; case valor2: bloque_de_sentencias; ……. default : bloque_de_sentencias; Donde se entiende a un bloque de sentencias como a un grupo de una o más instrucciones. Se recomienda que si es más de una sentencia, las instrucciones se agrupan entre llaves. Una de las características de la instrucción switch de C, es su comportamiento en cascada, es decir, al encontrar una sección en que el valor de la variable calze, entra al bloque de instrucciones y las ejecuta todas de ahí hacia abajo, hasta el final del switch. Para evitar este comportamiento, a veces no deseado, se acostumbra a poner como última instrucción de un bloque a la instrucción break; la cual indica que termina la ejecución del bloque y se sale del switch. La sentencia default, se ejecuta si no se encuentra ninguna correspondencia. Colocar default es opcional. Ejemplo: switch(numero) { case 1: a= a+1; break; case 2: a = a+2; b = b-1;

break; case 3: c = c+2;

d = d-1; break;} case 4 : x = 1; y = y+2; break; case 5 : y = y+3 break; default : y = 0; }


14 | P a g e

CAPITULO VII: “Iteraciones en C” Iteraciones Fijas : Es una estructura de control, que define un número fijo de iteraciones sobre un grupo de expresiones. En C, la sentencia es for y su sintaxis es: for (inicialización; condición; incremento) { grupo_de_instrucciones; } Ejemplo: a = 1 ; b = 5; for (i = 1; i <= b; i++) a = a * i; Iteración while: Es una estructura de control, que realiza una iteración con ingreso condicionado sobre un grupo de expresiones. En C su sintaxis es: while (condición) { sentencias; } Mientras la evaluación de la condición sea verdadera, se ejecutarán las sentencias del bloque. Ejemplo: Loop = 10; While (loop >= 1) { loop = loop – 1; } Iteración do-while: Es una estructura de control, que realiza una iteración con salida condicionada. (Se ejecuta al menos una vez, sirve para validaciones). En C, su sintaxis es: do { sentencias; } while (condición); Ejemplo: loop=10; do { loop = loop –1; } while (loop >=1) Importante: ¿Cuál es la diferencia entre una sentencia while y una do-while? La sentencia while realiza la evaluación de la expresión y, sólo si ella es verdadera, ejecuta la acción. La sentencia do-while ejecuta las sentencias y luego evalúa la expresión. Siempre las sentencias se realizan al menos una vez. Saltos Incondicionados: Existen dos instrucciones en C que permiten saltos incondicionados dentro de las sentencias de una iteración. Estas, algunas veces, son necesarias, ante la detección de una


15 | P a g e

condición anómala, necesidad de rechequear la condición de iteración o, aún peor, salir de la iteración en forma abrupta. Para las situaciones anteriores, C provee las siguientes instrucciones: break;

1. Usada para finalizar un case en una sentencia switch. 2. Se puede usar para forzar una salida inmediata dentro de una iteración (for, while, do while).

Ejemplos: for (t =0; t < 100; t ++) { cont = 1; for ( ; ; ) { printf(“%d”, cont); cont ++; if (cont = = 10) break; } } Este programa imprime los números del 1 al 9, cien veces. Cada vez que el compilador encuentre break; el control vuelve a la iteración externa. continue; Realiza un salto hasta la condición de chequeo de la iteración. do { scanf(“%d”,&x); if (x < 0) continue; printf(“%5d”,x); } while (x != 100); Este programa muestra sólo números positivos. Se sale cuando se ingresa el número 100. Uso apropiado de una iteración: Dadas las tres formas de estructuras de control que provee C, cabe realizar la siguiente pregunta: ¿Cuándo usar cada una?

a) Si usted no quiere que el cuerpo de la iteración sea realizado cuando la condición empieza con

valor falso, usar while.

b) Si usted quiere que las sentencias siempre sean ejecutadas, al menos una vez, use do-while. c) Si el número de iteraciones que se va a realizar está determinado por una constante, o una

variable que no va a modificarse en el cuerpo del bloque, utilice for.


16 | P a g e

CAPITULO VIII: “Arreglos en C” Definición: Un arreglo es una colección de variables del mismo tipo, denominados por un nombre en común. En C, todos los elementos de un Array constan de espacios de memoria contigua. Al especificar un arreglo se deben indicar: el tipo de los datos que serán almacenados, el nombre del arreglo y el número de elementos que tendrá el Array, encerrado entre paréntesis cuadrados: tipo nombre_de_variable [tamaño]; Ejemplos: int numeros[10]; char sexo[25]; float ing[20], egr[20], saldo[20]; Acceso: La forma de accesar los elementos del arreglo es mediante el manejo de un subíndice, que corresponde al número entre paréntesis. El subíndice, puede ser cualquier variable o constante entera. Ejemplo: i = 3; saldo[i] = ing[i] – egr[i] + saldo[i-1]; Elementos: En C, todos los arreglos tienen el 0 como subíndice, y comienzan siempre desde él. Así, al definir un arreglo de N elementos, los subíndices varían entre el 0 y (N – 1). Ejemplo: char sex[10]; Declara un array de caracteres de 10 elementos, desde sex[0] hasta sex[9]. Inicialización: Tal como en otras variables, los arreglos deben ser inicializados adecuadamente. Esta inicialización puede realizarse al momento de la declaración o después de ella. Ejemplos: int lista[4] = {10,38,5,20}; int x[10]; for (i = 0; i < 10; i++) x[i] = i; (Nota: Ver programas de Arreglos en el Apéndice) Arreglos Multidimensionales. El lenguaje C, permite definir arreglos multidimensionales. Estos permiten el manejo de matrices u otros elementos de múltiples dimensiones. La sintaxis de un arreglo multidimensional es: tipo nombre[tamaño] [tamaño] ... [tamaño]; Ejemplo: int ventas_anuales[12][31]; Este es un arreglo bidimensional, que contiene las ventas diarias de los 12 meses del año. Acceso: La forma de accesar los elementos del arreglo es mediante el manejo de sus subíndices. Ejemplo: int a[10][20];


17 | P a g e

Define un arreglo cuyo primer índice varía entre 0 y 9, y el segundo entre 0 y 19. El primer elemento se encuentra en: a[0][0]. Para referirse al elemento en la posición 8,15, se debe usar: a[7][14]; Para accesar el punto 8,15 del array, se debe usar: a[8][15]; (Nota: Ver programas de Matrices en el Apéndice) Arreglos y Strings: Un string es simplemente un arreglo de char con carácter nulo que indica el fin del string. Así, la declaración: char nombre[30]; Tiene 29 elementos usables. Todo array de caracteres en C, debe finalizar con el carácter nulo, usted debe asegurarse de definir un tamaño suficiente para incluirlo. Ejemplos: char letras[5] = ‘ABCD’; char letras[5] = {‘A’, ‘B’, ‘C’, ‘D’, ‘\0’}; Observe que en la última declaración de letras, se debe incluir explícitamente el carácter nulo.

CAPITULO IX: “Funciones de caracteres y strings” Definición: Un string es un array de caracteres que finaliza con el carácter nulo, y un carácter es el valor de un byte. Las funciones de manipulación de strings usan el header <string.h> y las que manipulan caracteres, el header <ctype.h>. Ambos se encuentran en la biblioteca estándar definida por el ANSI C. <string.h> : Algunas de las funciones definidas en este header son: a) strcpy(S1,S2): Copia el string S2 en S1, incluyendo el carácter nulo; regresa a S1. b) Strcat(S1,S2): Concatena el string S2 al final del string S1; regresa a S1. c) Strcmp(S1,S2): Compara el string S1 con el string S2; regresa un número entero: < 0 si S1

>S2; 0 si S1 = S2; >0 si S1 >S2. d) Strlen(S1) : Regresa la longitud del string S1. <ctype.h> : Las funciones definidas en este header, regresan un entero distinto de cero(0); si el carácter c que tiene como argumento satisface a la condición descrita. Algunas funciones son: a) isalnum(c): Chequea que el carácter c sea una letra (mayúscula o minúscula) o un dígito. b) isalpha(c): Chequea que c sea una letra (mayúscula o minúscula). c) iscntrl(c): Chequea que c sea un carácter de control. d) isdigit(c): Chequea que c sea un dígito.


18 | P a g e

e) islower(c): Chequea que c sea una letra minúscula. f) isupper(c): Chequea que c sea una letra mayúscula. g) isspace(c): Chequea que c sea un espacio, retorno, tabulador, avance de página o nueva línea.

CAPITULO X: “Funciones y Procedimientos” Introducción: Una de las ideas más importantes en la codificación de un programa, es la de dividir un programa complejo en subtareas menos difíciles, con el fin de atacar el problema desde sus aspectos más generales a los más particulares (Diseño TOP-DOWN). También es importante distinguir que muchas de estas subtareas en que se divide nuestro problema, presentan estructuras similares con variación de algunos parámetros. Otro aspecto que cabe señalar, es el uso de las librerías de funciones. Por ejemplo, cada vez que necesitamos realizar operaciones de E/S, utilizamos una librería de funciones. Es decir, estamos aprovechando la codificación que otra persona realizó, simplificando en gran medida nuestra codificación. Los procedimientos y las funciones son los elementos de programación que ponen en práctica las tres ideas anteriores: a) Descomposición de un gran problema en subtareas. b) Tareas similares con sólo parámetros de entrada diferentes. c) Reutilización del código. Funciones: La idea de función, está generalmente asociada a una idea matemática, es decir, a una expresión matemática que, dados unos parámetros, nos entrega un valor. En C, una función es mucho más que una expresión matemática. Podríamos decir que se trata de un trozo de código independiente de nuestro programa, que puede tener o no parámetros, que dados los valores de entrada ejecuta una serie de acciones que finalmente se expresan en el valor de la función. Procedimientos: Un procedimiento es similar a una función a excepción de que no retorna valor. Sin embargo, contiene un cuerpo con cierta funcionalidad, pudiendo retornar los valores en sus argumentos. Sintaxis en C: Las funciones en C, presentan la siguiente forma: tipo_función nombre(lista_parámetros) { cuerpo_de_la_función return (valor); } Donde, tipo_función, corresponde al tipo de valor que devuelve la función, pudiendo ser cualquier tipo válido (int,float, char, etc.). Si se trata de un procedimiento, existe un tipo especial que define el no retornar nada: void. La sentencia return, tiene dos usos importantes. Primero, fuerza una salida inmediata de la función en que se encuentra, siguiendo la ejecución en el código que llamó a la función. El otro uso, es para devolver un valor. En C, todas las funciones, excepto las de tipo void, devuelven un valor. Este valor, se especifica explícitamente en la sentencia return. Cuando una función no se define de tipo void y además no se especifica un valor de vuelta, entonces el valor devuelto por la función queda técnicamente indefinido. Toda función que no se declare como void, puede ser usada como operando en cualquier expresión válida de C. Por ejemplo: if (max(x,y) > 100) printf(“Mayor:”,max);


19 | P a g e

No es necesario asignar siempre el valor devuelto por alguna función. Cuando esto ocurre, el valor devuelto simplemente se ignora. En C, es fundamental colocar el tipo de la función, pues de lo contrario, se interpretará que la función retorna un entero. En main(), la sentencia return devuelve un código de terminación al proceso de llamada, un valor 0 (cero) indica que el programa ha terminado normalmente. Todos los demás valores indican que se ha producido algún tipo de error. Declarar una sentencia return en main(), es opcional. Pero, es una buena costumbre hacerlo. Argumentos de funciones: Cada función que use argumentos, debe declarar variables que acepten los valores de los argumentos. Estas variables se llaman parámetros formales de la función. Ejemplos: mul(int a, int b) { return a*b; } La función mul, tiene dos parámetros: a y b Al igual que, como en otro tipo de variables, se pueden hacer asignaciones a los parámetros formales de una función o usarlos en cualquier expresión válida en C. Llamada por Valor: En esta forma de pasar argumentos, se copia el valor del argumento en el parámetro formal de la sub-rutina. De esta manera, los cambios producidos en los parámetros de la sub-rutina no afectan a las variables que se usan en la llamada. Ejemplo: #include <stdio.h> void cambiar(int x, int y); main() { int a,b; a = 5; b = 8; cambiar(a,b); printf(“%d”,a); return 0; } /* Coloca el valor del segundo parámetro en el primero y viceversa */ void cambiar(int x, int y) { int temp; temp = x; x = y; y = temp; } Llamada por Referencia: Es otra forma de pasar argumentos a una sub-rutina. En este método, se copia la dirección del argumento en el parámetro formal, cualquier cambio producido en los parámetros de la sub-rutina, modifican a la variable usada en la llamada.


20 | P a g e

Para causar una llamada por referencia se debe pasar un puntero al argumento, esto se hace incorporando un amppersand (&) delante de él. Además, se debe declarar el respectivo parámetro formal de tipo puntero. Ejemplo: #include <stdio.h> void cambiar(int *x, int *y); main() { int a,b; a = 5; b = 8; cambiar(&a,&b); printf(“%d”,a); return 0; } /* Coloca el valor del segundo parámetro en el primero y viceversa */ void cambiar(int *x, int *y) { int temp; temp = *x; *x = *y; *y = temp; } Cuerpo de una función: El cuerpo de una función corresponde al código de implementación de la función. Este código, al igual que cuando es implementado en el main(), puede contener variables de uso auxiliar en sus primeras líneas. Sin embargo, a diferencia del main(), estas variables serán locales a esta función, vale decir sólo pertenecen a la función, no pudiendo ser accesada desde otra función o desde el main().

CAPITULO XI: “E/S en Archivos” El sistema de archivos en ANSI C, se compone de varias funciones que se encuentran en el header <stdio.h>. Puntero a Archivo: Se debe indicar sobre qué archivo se desea realizar la lectura o escritura. Para esto, hay que emplear una variable de tipo puntero que representará al archivo. Un puntero a un archivo es un puntero a una información que define varias cosas sobre él, incluyendo su nombre, su estado y su posición actual. La variable de tipo puntero se declara bajo la siguiente sintaxis: FILE *nombre; Abrir un Archivo: Consiste en asociar un archivo externo (desde un directorio de nuestro sistema), con la variable de tipo puntero que lo referencia en el programa. Para esto, se utiliza la función fopen() que devuelve un puntero de tipo FILE. La asociación se logra a través de la siguiente declaración: fp = fopen (nombre_archivo, tipo_acceso); Donde fp corresponde a la variable de tipo FILE ya declarada, y a la que se le asociará el puntero que retorna fopen(). El nombre del archivo se especifica en nombre_archivo y el tipo_acceso corresponde al modo en que se trabajará sobre el archivo.


21 | P a g e

Se puede abrir un archivo en modo texto o en modo binario. En modo texto, las secuencias de salto de línea se convierten a caracteres de salto de línea en la lectura. En la escritura ocurre lo contrario, los caracteres de salto de línea se convierten en saltos de línea. Estas conversiones no ocurren en archivos binarios. A continuación, se indicarán los distintos tipos_acceso : Archivos de Texto “r” Abre para lectura. “w” Crea para escritura “a” Abre para añadir “r+” Abre para lectura/escritura

“w+” Crea para lectura/escritura “a+” Abre o crea para lectura/escritura Para archivos binarios se debe agregar una letra b al final. Ejemplo: fp = fopen(“prueba”, “w”) Se crea el archivo prueba para escritura. Si el archivo existe se borra y se crea uno nuevo, si no existe, simplemente se crea. Para abrir archivos de lectura estos deben existir, de lo contrario devuelve un error. Validación: Si por alguna razón la función fopen() fallara, retornará una referencia nula NULL. Por esto, es conveniente al abrir un archivo, usar la siguiente operación: if (( fp = fopen(“prueba”,”w”)) = = NULL) printf(“Error: Al abrir el archivo prueba”); Escritura de archivos: Se utiliza la función fprintf(), su sintaxis es similar a printf() salvo que como primer argumento debe llevar la variable de tipo FILE que se asoció al archivo: fprintf(var_FILE,str_control, arg1, arg2, ...); Lectura de Archivos: Se utiliza la función fscanf() que es similar a scanf(). También, se debe incluir la variable de tipo FILE a la que se asoció el archivo: fscanf(var_FILE, s_control, &arg1, &arg2, ...); Cerrar un Archivo: Se utiliza la función fclose(), que elimina la referencia al archivo abierto con fopen() y realiza un cierre formal del archivo. La sintaxis es la siguiente: fclose(var_FILE); Cuando fclose() tiene éxito, se devuelve un 0 y si ocurre un error se devuelve EOF. Generalmente, fclose() falla cuando se ha retirado antes de tiempo un diskette o cuando no queda espacio libre en él.


22 | P a g e

APENDICE A

FUNCIONES DE C

FUNCION TIPO PROPOSITO INCLUDE

abs(i) int Retorna el valor absoluto de i stdlib.h

atof(s) double Convierte la cadena a una cantidad en doble precisión stdlib.h

atoi(s) int Convierte la cadena a un entero stdlib.h

atol(s) long Convierte la cadena s en un entero largo stdlib.h

exit(u) void Cerrar todos los archivos y buffers y terminar el programa stdlib.h

rand(void) int Retorna un valor aleatorio positivo stdlib.h

acos(d) double Retorna el arcoseno de d math.h

asin(d) double Retorna el arco seno de d math.h

atan(d) double Retorna el arco tangente de d math.h

atand2(d1,d2) double Retorna el arco tangente de d1/d2 math.h

cos(d) double Retorna el coseno de d math.h

cosh(d) double Retorna el coseno hiperbólico de d math.h

exp(d) double Elevar d a la potencia de e=2.711182818 es la base de los logaritmos naturales

math.h

fabs(d) double Retorna el valor absoluto de d math.h

floor(d) double Retorna el valor redondeado por defecto al entero menor más cercano

math.h

fmod(d1/d2) double Retorna el resto de d1/d2 con el mismo signo que d1 math.h

labs(l) long int Retorna el valor absoluto de l math.h

log(d) double Retorna el logaritmo natural de d math.h

log10(d) double Retorna el logaritmo (en base 10) math.h

pow(d1,d2) double Retorna d1 elevado a d2 math.h

sin(d) double Retorna el seno de d math.h

sinh(d) double Retorna el seno hiperbólico de d math.h

sqrt(d) double Retorna la raíz cuadrada de d math.h

tan(d) double Retorna la tangente de d math.h

fclose(f) int Cierra el archivo f. Retorna un 0 si el archivo se ha cerrado con éxito

stdio.h

feof(f) int Determina si se ha encontrado un fin de archivo. Si es así, devuelve un valor distinto de 0

stdio.h

fopen(s1,s2) file* Abre un archivo llamado s1, del tipo s2. Retorna un puntero al archivo

stdio.h

fread(s,i1,i2,,f) int Leer i2 elementos, cada uno de tamaño i1 bytes, desde el archivo f hasta la cadena s

stdio.h


23 | P a g e

FUNCION TIPO PROPOSITO INCLUDE

fwrite(s,i11,i2,f) int Escribir i2 elementos, cada uno de i1 byte desde la cadena s hasta el archivo f

stdio.h

getchar(void) int Lee un carácter desde dispositivo estándar stdio.h

gets(s) char* Lee una cadena desde dispositivo estándar stdio.h

printf(...) int Escribe datos en el dispositivo de salida estándar stdio.h

putchar(s) int Escribe un carácter en el dispositivo de salida estándar stdio.h

puts(s) int Escribe una cadena en el dispositivo estándar stdio.h

rewind(f) void Mueve el puntero al principio del archivo f stdio.h

scanf(...) int Lee datos desde el dispositivo de entrada estándar stdio.h

getch() int Espera que se le ingrese un carácter y devuelve el valor, pero no lo muestra en pantalla

conio.h

getche() int Espera que se le ingrese un carácter y de vuelve el valor, mostrándolo en pantalla

conio.h

isalnum( c) int Determina si el argumento es alfanumérico. Retorna un valor distinto de 0 si es cierto; en otro caso, devuelve 0

ctype.h

isalpha( c) int Determina si el argumento es alfabético. Retorna un valor distinto de 0 si es cierto en otro caso, devuelve 0.

ctype.h

isdigit( c) int Determina si el argumento es un dígito decimal. Retorna un valor distinto de 0 si es cierto; en otro caso devuelve 0

ctype.h

islower( c) int Determina si el argumento es una minúscula .Retorna un valor distinto de 0 si es cierto; en otro caso devuelve 0

ctype.h

isspace( c) int Determina si el argumento es un espacio en blanco. Retorna un valor distinto de 0 si es cierto; en otro caso devuelve 0

ctype.h

isupper(c ) int Determina si el argumento es una mayúscula. Retorna un valor distinto de 0 si es cierto, en otro caso devuelve 0

ctype.h

tolower int Convierte una letra a minúscula ctype.h stdlib.h

toupper int Convierte una letra a mayúscula ctype.h stdlib.h

strcmp(s1,s2) int Compara dos cadenas lexicográficamente Retorna un valor negativo si s1<s2; un 0 si s1=s2; y un valor positivo si s1>s2 Esta sentencia considera las mayúsculas y las minúsculas

string.h

strcmpi(s1,s2) int Compara dos cadenas lexicográficamente. Retorna un valor negativo si s1<s2; un 0 si s1=s2 y un valor positivo si s1>s2 Compara sin considerar las mayúsculas y las minúsculas

string.h

strcpy(s1,s2) char* Copia la cadena s2 en s1 string.h

strlen(s,c) int Retorna el número de caracteres de la cadena string.h

strset(s,c) char* Pone todos los caracteres de s en c, (excluyendo el carácter nulo del final \0)

string.h

NOTAS: Tipo se refiere al tipo de la cantidad devuelta por la función. Un asterisco (*) denota un puntero. c denota un argumento de tipo carácter d denota un argumento de doble precisión f denota un argumento archivo i denota un argumento entero l denota un argumento entero largo p denota un argumento puntero s denota un argumento cadena o string u denota un argumento entero sin signo


24 | P a g e

APENDICE B: A continuación un programa sin procedimientos ni funciones que incluye algunos comandos: /* MENU-NUM.C*/ # include <stdio.h> #include <conio.h> int n1,n2,n3,may,prom,suma,m1,m2,m3; char op1; main() { do {

clrscr(); gotoxy(30,2);printf("Menú Principal"); gotoxy(30,3);printf("=============="); gotoxy(30,4);printf("1....Encontrar el mayor"); gotoxy(30,5);printf("2....Calcular el Promedio"); gotoxy(30,7);printf("3....Salida"); gotoxy(30,9);printf("Opción [ ]\b\b");op1=getch(); switch(op1) {

case '1': clrscr(); gotoxy(30,1); printf("Ingresar 3 Números y encontrar el Mayor");

gotoxy(30,2); printf(“---------------------------------------“); gotoxy(10,5); printf("Primer Número : "); gotoxy(10,7); printf("Segundo Número: "); gotoxy(10,9); printf("Tercer Número : "); gotoxy(26,5);scanf("%d",&n1); gotoxy(26,7);scanf("%d",&n2); gotoxy(26,9);scanf("%d",&n3); may=n1; if (n2>may) may=n2; if (n3>may) may=n3; gotoxy(10,12);printf("El número Mayor es: %d",may);getch(); break;

case '2': clrscr(); n1=0;n2=0;n3=0;prom=0;suma=0; gotoxy(30,1);printf("Ingresar 3 Números y Calcular el Promedio");

gotoxy(30,2);printf("========================================="); gotoxy(10,5);printf("Primer Número: "); gotoxy(10,7);printf("Segundo Número: "); gotoxy(10,9);printf("Tercer Número: "); gotoxy(26,5);scanf("%d",&n1); gotoxy(26,7);scanf("%d",&n2); gotoxy(26,9);scanf("%d",&n3); suma=n1+n2+n3; prom=suma/3; gotoxy(10,12);printf("El Promedio es : %d",prom); getch(); break; }


25 | P a g e

} while (op1!='3'); }

Guia Lenguaje C icel

Documents