Lenguaje C Erwin Meza Vega
Outline 1 Introducción 2 Tipos básicos de datos 3 Estructuras de control 4 Funciones 5 Ejemplos de funciones 6 Tipos compuestos de datos 7 Arreglos 8 Apuntadores (punteros) 9 Cadenas de caracteres
Introducción Lenguaje C
Introducción Historia El lenguaje C fue creado junto con el sistema operativo Unix. Unix fue escrito originalmente en lenguaje ensamblador, pero luego de comprender su potencial, sus creadores decidieron, en 1972, reescribirlo en un nuevo lenguaje, llamado C. Este lenguaje fue desarrollado por Dennis Ritchie en los Laboratorios Bell en Estados Unidos. C fue estandarizado a nales de los años 80, por lo que actualmente se le conoce como ANSI C.
Introducción Características Un programa en ANSI C (no C++) puede ser compilado para ejecutarse en virtualmente cualquier sistema operativo. Permite denir variables, constantes y funciones con una sintaxis relativamente simple. Ofrece estructuras básicas de control (decisión - selección ) y repetitivas. Fuertemente tipado: Es necesario denir el tipo de datos para las variables y las funciones. Cuenta con un conjunto reducido de palabras clave (es decir, palabras que tienen signicado dentro del lenguaje de programación)
Introducción Características Aunque su funcionalidad básica es limitada, se apoya en una serie de librerías estándar (ANSI) que ofrecen funciones adicionales Es posible extenderlo mediante la implementación de librerías adicionales a la librería estándar. Sus tipos de datos simples son comprendidos por la mayoría de procesadores actuales. Es posible crear nuevos tipos de datos complejos (estructuras y uniones) de forma sencilla. Permite acceder y modicar directamente la memoria por medio de apuntadores.
Introducción Primer programa en C #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { printf("hola, mundo!\n");
Introducción Codicación de programas en C Un programa en C es un archivo de texto, que puede ser creado usando: El bloc de notas, o una aplicación similar (no procesadores de palabras) Un editor más especializado, como NotePad++, PSPad, Vi, Emacs, etc. Un entorno de desarrollo, el cual usualmente incluye las herramientas para compilar el programa
Introducción Compilación de programas en ANSI C Para crear programas ejecutables a partir de código fuente en lenguaje C, se requiere un programa especíco llamado compilador. En Linux, se puede instalar y usar el compilador gcc. En Windows, se puede instalar el entorno de desarrollo Dev-C++, el cual usa una versión modicada del compiador gcc que funciona en Windows. También se puede usar el excelente compilador Tiny C Compiler, el cual puede ser instalado en Windows.
Introducción Compilación del programa en Dev-C++ Se debe abrir el archivo en C, y elegir la opción Compilar del menú Ejecutar.
Introducción Compilación por línea de comandos Se debe abrir una ventana del símbolo del sistema, y ejecutar el comando para compilar el archivo que contiene el código en C. Para que esto funcione, el directorio donde fue instalado el compilador debe estar incluido dentro de la variable PATH del entorno. En este caso, el programa se compiló dos veces, usando el compilador gcc y el compilador tcc.
Introducción Ejecución de un programa Una vez que se ha creado un archivo ejecutable a partir del código fuente en lenguaje C, se debe iniciar la ejecución del programa. Se recomienda aprender a ejecutar el programa usando un intérprete de comandos (el símbolo del sistema en Windows o el shell en Linux). Esto permite comprender mejor el funcionamiento del programa.
Tipos básicos de datos Tipos básicos de datos
Tipos básicos de datos Tipos básicos de datos Entero: Representa números enteros con o sin signo. La palabra reservada unsigned se usa para denir una variable sin signo. Número de punto otante: Representa números con decimales. Caracter: Es un tipo de datos especial, ya que se comporta como un número entero muy pequeño (con signo o sin signo), pero también se puede almacenar un carácter (un número, una letra del alfabeto inglés o algunos códigos especiales como n de línea)
Tipos básicos de datos Números enteros Tipo Tamaño en bytes Rango de valores char 1 byte -128-127 unsigned char 1 byte 0-255 short 2 bytes -32.768-32.767 unsigned short 2 bytes 0-65.535 long 4 bytes -2.147.483.648-2.147.483.647 unsigned long 4 bytes 0-4.294.967.295 int 2 o 4 bytes -32.768-32.767-2.147.483.648-2.147.483.647 unsigned int 2 o 4 bytes 0-65535, 0-4.294.967.295 0-4.294.967.295 El tipo int es especial, debido a que depende del procesador en el cual se ejecute el programa.
Tipos básicos de datos Números de punto otante Tipo Tamaño en bytes Rango de valores Precisión oat 4 bytes 1.2*10-38 - 3.4*10 38 6 decimales double 8 bytes 2.3*10-308 - 1.7*10 308 16 decimales long double 10 bytes 3.4*10-4932 - 1.1*10 4932 19 decimales
Tipos básicos de datos Caracteres Un carácter representa la mínima unidad de almacenamiento en memoria. Generalmente un char tiene un tamaño de 1 byte, por lo cual puede almacenar: Números entre -128 y 127 (char) Números entre 0-255 (unsigned char) Además, en C, es posible almacenar un caracter (a, b, c,!,..) en una variable de tipo char. Esto se debe a que estos caracteres se codican en ASCII como un número entero menor o igual a 255.
Tipos básicos de datos Operador sizeof En lenguaje C, el operador sizeof permite obtener el tamaño en bytes de un tipo de datos. Esto puede ser especialmente útil para vericar si un programa que depende de un tipo de datos numérico funcionará correctamente. En un computador personal, el operador sizeof retornará: Tipo de datos Operación Resultado char sizeof(char) 1 short sizeof(short) 2 long sizeof(short) 4 int sizeof(int) 4
Tipos básicos de datos Ejemplo de tipos básicos de datos #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int a; int b; double f; char x; a = 5; b = 2; f = (double)a / (double)b; x = 'a'; x = x + 1; printf("a= %d b=%d f=%1.3f x=%c\n", a, b, f, x);
Estructuras de control Estructuras de control
Estructuras de control Decisión #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int x; scanf("%d", &x); Estrutura básica if.. else. La secuencia else... es opcional. Si la secuencia solo consta de una instrucción, se pueden omitir los corchetes {. if ((x % 2) == 0) { printf("%d es par\n", x); else { printf("%d es impar\n", x);
Estructuras de control Selección #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int x; scanf("%d", &x); switch (x) { case 1: printf("selecciono 1\n"); break; case 2: printf("selecciono 2\n"); break; case 3: printf("selecciono 3\n"); break; default: printf("no selecciono 1, 2 ni 3\n"); break; Permite ejecutar diferentes secuencias de acuerdo con el valor almacenado en una variable. Cada caso se debe terminar con break, de lo contrario los casos se ejcutarán uno tras otro (en cascada) El caso alternativo se especica con la palabra reservada default.
Estructuras de control Mientras.. hacer y Hacer.. mientras #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int i; int n; int suma; #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int i; int n; int suma; scanf("%d", &n); i = 1; suma = 0; while (i <= n) { suma = suma + i; i = i + 1; printf("%d\n", suma); scanf("%d", &n); i = 1; suma = 0; do { suma = suma + i; i = i + 1; while(i <= n); printf("%d\n", suma);
Estructuras de control Estructura para.. hacer #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int i; int n; int suma; #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int i; int n; int suma; scanf("%d", &n); suma = 0; for (i=1; i<=n; i++) { suma = suma + i; printf("%d\n", suma); scanf("%d", &n); suma = 0; for (i=n; i>=1; i--) { suma = suma + i; printf("%d\n", suma);
Funciones Funciones
Funciones Concepto Una función es una secuencia de instrucciones que realiza una tarea especíca. Sus características más importantes son: Puede recibir cero, uno o más datos de entrada (parámetros) por valor o por referencia. Puede retornar un dato de salida, o ningún dato. Toda función debe tener un tipo de datos de retorno. Para las funciones que no retornan un valor, se usa el tipo especial void (vacío). Puede ser usada (invocada) en múltiples ocasiones en un programa. La librería estándar de C proporciona una gran cantidad de funciones predenidas, que permiten leer datos, imprimir por pantalla, realizar operaciones trigonométricas, operar sobre cadenas de caracteres, etc.
Funciones Funciones en Lenguaje C Todo programa en lenguaje C inicia su ejecución en la secuencia de instrucciones denida en una función especial, llamada main. Esta función recibe dos parámetros opcionales de línea de comandos: argc: Número de argumentos pasados al programa por línea de comandos argv: Argumentos pasados al programa como cadenas de caracteres. Dentro de la secuencia de instrucciones de la función main, se puede usar otras funciones de la librería de C, o funciones denidas por el usuario. Las funciones a su vez pueden usar otras funciones para cumplir con el propósito para el que fueron diseñadas. Es posible crear nuevas funciones, las cuales se deben denir antes de ser utilizadas.
Funciones Función main en C #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { printf("estoy en el programa principal\n"); En este caso, el programa imprimirá por pantalla "Estoy en el programa principal" y terminará su ejecución.
Funciones Ejemplo: Uso de funciones de la librería estándar #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv) { int n; printf("escriba el valor de n "); scanf("%d", &n); printf("el valor de n es: %d\n", n); La función scanf se invoca pasando la variable n por referencia, ya que dentro de esta función se lee un dato por teclado y se almacena en la posición de memoria de la variable n. La función printf se invoca pasando la variable n por valor.
Funciones Entrada y salida estándar La función scanf permite leer datos de la entrada estándar, que generalmente representa el teclado del computador. La función printf permite enviar datos a la salida estándar, que generalmente representa la pantalla.
Funciones Denición de funciones En un programa se pueden denir nuevas funciones, siguiendo las siguientes recomendaciones: Una función debe estar declarada antes de ser usada por la función principal (main) o por otras funciones denidas en el programa. Toda función debe tener un valor de retorno. En caso que la función no retorne ningún dato, se debe usar el tipo void. Una función puede recibir cero, uno o más parámetros de entrada. Cuando se desea terminar la ejecución de la función y devolver un resultado, se debe usar la instrucción return.
Ejemplos de funciones Función sin datos de entrada y sin dato de retorno #include <stdio.h> #include <stdlib.h> void saludar(void) { printf("hola\n"); void despedirse(void) { printf("adios\n"); int main(int argc, char * argv[]) { saludar(); despedirse();
Ejemplos de funciones Función con parámetros de entrada y valor de retorno #include <stdio.h> #include <stdlib.h> int sumar(int x, int y) { return x + y; int main(int argc, char * argv[]) { int a; int b; int resultado; printf("escriba el valor de a: "); scanf("%d", &a); printf("escriba el valor de b: "); scanf("%d", &b); resultado = sumar(a, b); printf("el resultado es: %d\n", resultado);
Tipos compuestos de datos Tipos compuestos de datos
Tipos compuestos de datos Estructuras En ocasiones en conveniente agrupar los datos de una forma que tenga sentido para el algoritmo o el programa que estamos desarrollando. Por ejemplo, considere el siguiente problema: Construir un algoritmo que dados los datos (x, y) para dos puntos, calcule la distancia euclidiana entre ellos. En este caso, sería conveniente llevar el concepto de punto al algoritmo, y por supuesto, al lenguaje de programación.
Tipos compuestos de datos Denición de una estructura compuesta struct punto { int x; int y; ; struct punto a; struct punto b; Denición de un nuevo tipo de datos, la estructura punto y de dos variables de este tipo. En este caso, las variables a y b tienen dos atributos internos (x e y), a los cuales se puede (y generalmente debe) asignar valores independientes. El acceso a los atributos de una estructura se realiza mediante el operador punto '.'.
Tipos compuestos de datos Algoritmo de distancia euclidiana estructura punto entero x entero y fin_estructura algoritmo distancia_euclidiana punto a, punto b, decimal d inicio leer a.x, a.y leer b.x, b.y funcion distancia (punto a, punto b) : decimal inicio dx = a.x - b.x dy = a.y - b.y resultado = raiz_cuadrada( ( dx * dx) + (dy * dy)) d = distancia(a, b) retornar resultado fin imprimir d fin_funcion
Tipos compuestos de datos Programa de distancia euclidiana #include <stdio.h> #include <stdlib.h> #include <math.h> struct punto { int x; int y; ; double distancia(struct punto a, struct punto b); int main(int argc, char * argv[]) { struct punto a; struct punto b; double d; double distancia(struct punto a, struct punto b) { double dx; double dy; double resultado; dx = a.x - b.x; dy = a.y - b.y; resultado = sqrt( (dx * dx) + (dy * dy) ); scanf("%d %d", &a.x, &a.y); scanf("%d %d", &b.x, &b.y); d = distancia (a, b); return resultado; printf("%3.5f\n", d);
Arreglos Arreglos
Arreglos Concepto de arreglo Es una colección en memoria de elementos del mismo tipo. Estos elementos se encuentra almacenados uno tras otro en la memoria. En lenguaje C es posible denir y utilizar arreglos de tipos básicos o de tipos compuestos de datos. Es decir, es posible denir un arreglo que almacene: enteros, estructuras, arreglos, etc. Una vez creado, un arreglo tiene un tamaño jo, lo cual signica que puede almacenar un número determinado de elementos. Si se desea adicionar elementos a un arreglo más allá de su capacidad, se deberá crear un nuevo arreglo. En C, las posiciones de los elementos de un arreglo se enumeran desde cero.
Arreglos Ejemplo - Arreglo de enteros #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int a[5]; a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4; a[4] = 5; printf("%d\n", a[2]); 1 2 3 4 5 Arreglo a en memoria:
Apuntadores (punteros) Apuntadores (punteros)
Apuntadores (punteros) Concepto Es una variable especial, que permite acceder a una posición de memoria. El dato que se almacena en el apuntador es la dirección de memoria que se desea acceder. Generalmente se usan para apuntar a la ubicación en memoria de otras variables de un programa (variables de tipos básicos, arreglos y otros apuntadores). También pueden apuntar a la ubicación de funciones de un programa. Los apuntadores proporcionan un gran nivel de exibilidad al programador, pero también representan riesgo de modicar la información existente en la memoria causando efectos secundarios, incluso errores graves en los programas.
Apuntadores (punteros) Uso básico de apuntadores #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int a; int * b; int * c; a = 5; b = &a; c = b; *c = 10; printf("%d\n", a); Al ejecutar este programa, se obtiene como salida 10. Esto se debe a que primero se apuntó b a la posición de memoria de la variable a, y luego se apuntó c a la misma posición de memoria. Al modicar el valor apuntado por c, se modicó el valor original de a.
Apuntadores (punteros) Reserva dinámica de memoria En algunos programas, no se sabe de antemano cuanta memoria se va a necesitar. Por tal razón, es necesario crear las variables de forma dinámica, a medida que se requieren. La librería estándar de C ofrece funciones para reservar memoria de forma dinámica, y para liberar la memoria asignada. Al reservar memoria, es necesario especicar el tamaño (en bytes) de la memoria que se requiere usar, para lo cual se usa generalmente el operador sizeof. Cuando se reserva memoria, se obtiene un apuntador a la nueva memoria reservada. Para liberar memoria, se debe especicar un apuntador a la ubicación de la memoria que se desea liberar.
Apuntadores (punteros) Ejemplo reserva dinámica de memoria #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int x; int * y; x = 5; y = (int*)malloc(sizeof(int)); *y = x; printf("%d\n", *y); *y = *y + 1; printf("%d\n", *y); free(y);
Apuntadores (punteros) Apuntadores a arreglos Los apuntadores pueden ser usados de forma nativa para acceder a los datos almacenados en un arreglo, y de ser necesario, modicarlos. Al asignar un arreglo a un apuntador, en éste se almacena la ubicación de memoria del primer elemento del arreglo. Al incrementar el apuntador usando el operador ++, se accede a la siguiente posición del arreglo. Al modicar el valor almacenado en el puntero, se modica la posición correspondiente en el arreglo.
Apuntadores (punteros) Ejemplo de apuntadores a arreglos #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int * p; int * q; int a[5] = {1, 2, 3, 4, 5; p = a; q = p; printf("%d\n", *p); q++; printf("%d\n", *q); *q++; printf("%d\n", *q); 1 2 3 4 5 1 3 3 4 5
Apuntadores (punteros) Apuntadores a estructuras Los apuntadores también se pueden usar para acceder a los atributos denidos en una estructura compleja. En este caso, al apuntador se asigna la referencia (&) a la posición de memoria de la variable de tipo complejo. Para acceder a los atributos de un apuntador a una estructura, se usa el operador echa -> También pueden usarse apuntadores a estructuras como parámetros en las funciones. En este caso, al modicar los datos almacenados en el apuntador, se estará modicando la variable original.
Apuntadores (punteros) Apuntadores a estructuras #include <stdio.h> #include <stdlib.h> int main(int argc, char * argv[]) { int x1; int y1; struct punto p; struct punto * q; scanf("%d %d", &p.x, &p.y); printf("[%d, %d]\n", p.x, p.y); q = &p; scanf("%d %d", &x1, &y1); p.x = x1; p.y = y1; printf("[%d, %d]\n", q->x, q->y);
Apuntadores (punteros) Apuntadores y paso por referencia en funciones Los apuntadores también se usan en las funciones, cuando se desea pasar parámetros por referencia. En este caso a la función se debe pasar como parámetro un apuntador (válido) o la referencia a la posición de memoria de una variable. La función recibe la referencia como un apuntador del tipo especicado como parámetro.
Apuntadores (punteros) Ejemplo de paso de apuntadores #include <stdio.h> #include <stdlib.h> struct punto { int x; int y; ; int main(int argc, char * argv[]) { int x1; int y1; struct punto p; scanf("%d %d", &p.x, &p.y); printf("[%d, %d]\n", p.x, p.y); void mover(struct punto * p, int n_x, int n_y) { p->x = n_x; p->y = n_y; scanf("%d %d", &x1, &y1); mover(&p, x1, y1); printf("[%d, %d]\n", p.x, p.y);
Cadenas de caracteres Cadenas de caracteres
Cadenas de caracteres Concepto Las cadenas de caracteres en C son un tipo especial de datos, que puede ser usado para muchos propósitos. De forma general, una cadena de caracteres es una secuencia de cero o más caracteres, que siempre debe nalizar con el carácter nulo (cuyo valor numérico es cero - 0). Por ejemplo, la cadena "Hola mundo" se almacena en memoria así: H o l a m u n d o 0 72 111 108 97 32 109 117 110 10 111 0
Cadenas de caracteres Arreglos y cadenas de caracteres #include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char * argv[]) { char * str = "Hola mundo"; int i; char c; printf("%s\n", str); i = 0; do{ c = str[i]; printf("#%c#", c); i++; while(str[i]!= 0); Una cadena de caracteres puede ser tratada como un arreglo de caracteres, en el cual su última posición siempre contiene el caracter nulo (0). El parámetro %s se usa en la función printf para imprimir una cadena de caracteres terminada en nulo. El algoritmo imprime los caracteres de la cadena en forma individual.
Cadenas de caracteres Arreglos y cadenas de caracteres #include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char * argv[]) { char str[] = {'H', 'o', 'l', 'a', ' ', 'm', 'u', 'n', 'd', 'o', 0, 'A', 'd', 'i', 'o', 's', 0; int i; char c; printf("%s\n", str); i = 0; do{ c = str[i]; printf("#%c#", c); i++; while(str[i]!= 0); Cuidado! Un arreglo de caracteres puede contener cero, una o más cadenas de caracteres. Esto se debe, a que, por denición, una cadena de caracteres es una secuencia de cero o más caracteres, seguidos de un carácter nulo. En este caso, el arreglo de caracteres contiene dos cadenas de caracteres. Ni la función printf, ni las instrucciones para imprimir cada caracter de la cadena, funcionan como se pensaría, ya que estas asumen que la cadena termina en el primer caracter nulo (0) encontrado.
Cadenas de caracteres Arreglos de cadenas de caracteres Es posible crear arreglos de cadenas de caracteres. En este caso, cada posición del arreglo contiene un apuntador al inicio de una cadena de caracteres. char * cadenas[10]; En la denición anterior, el arreglo cadenas tiene 10 posiciones, en cada una de las cuales se puede almacenar un apuntador al inicio de una cadena de caracteres.
Cadenas de caracteres Arreglos de cadenas de caracteres En un arreglo de cadenas de caracteres se pueden almacenar cadenas que se especican en el código de programa, o cadenas de caracteres que se han construido mediante reserva dinámica de memoria. En el segundo caso, siempre se debe garantizar que la memoria reservada para la cadena tenga el tamaño suciente. #include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char * argv[]) { char * cadenas[3]; int i; cadenas[0] = "Hola"; cadenas[1] = "Mundo"; cadenas[2] = (char*)malloc(80); strcpy(cadenas[2], "Hola mundo"); for (i=0; i<3; i++) { printf("%s\n", cadenas[i]);