-
Universidad Nacional Autónoma de
México
Facultad de Ingeniería
Lenguaje C
Autor: Ing. Israel Durán Martínez
Creado en Octubre 2007 Última actualización: Febrero 2010
Facultad de Ingeniería Lenguaje C
ÍNDICE
ÍNDICE ............................................................................................................................... 2
CAPÍTULO 1: INTRODUCCIÓN AL LENGUAJE C ....................................... 4 1.1 ORÍGENES DEL LENGUAJE C........................................................................................... 4 1.2 UN LENGUAJE DE NIVEL MEDIO...................................................................................... 4 1.3 UN LENGUAJE ESTRUCTURADO ...................................................................................... 5 1.4 COMPILADORES FRENTE A INTÉRPRETES........................................................................ 6 1.5 LA BIBLIOTECA Y EL ENLAZADO .................................................................................... 7 1.6 ENTORNOS DE DESARROLLO .......................................................................................... 7
CAPÍTULO 2: LENGUAJE C: ELEMENTOS BÁSICOS ................................ 9 2.1 ESTRUCTURA GENERAL DE UN PROGRAMA EN C............................................................ 9
2.1.1 Directivas del preprocesador .............................................................................. 10 2.1.2 Declaraciones globales ....................................................................................... 10 2.1.3 Función main( ) ................................................................................................... 10 2.1.4 Funciones definidas por el usuario ..................................................................... 10
2.2 COMENTARIOS ............................................................................................................. 11 2.3 IDENTIFICADORES ........................................................................................................ 12 2.4 PALABRAS RESERVADAS.............................................................................................. 13 2.5 TIPOS DE DATOS........................................................................................................... 13 2.6 VARIABLES .................................................................................................................. 16
2.6.1 Variables locales ................................................................................................. 16 2.6.2 Variables globales ............................................................................................... 17 2.6.3 Inicialización de variables .................................................................................. 18 2.6.4 Constantes ........................................................................................................... 19 2.6.5 Constantes de carácter de barra invertida.......................................................... 20
CAPÍTULO 3: OPERADORES Y EXPRESIONES ......................................... 22 3.1 OPERADORES ARITMÉTICOS......................................................................................... 22 3.2 OPERADORES RELACIONALES Y LÓGICOS..................................................................... 22 3.3 OPERADORES A NIVEL DE BITS ..................................................................................... 23 3.4 PRECEDENCIA DE LOS OPERADORES DE C .................................................................... 24
CAPÍTULO 4: INSTRUCCIONES DE CONTROL............................................ 25 4.1 INSTRUCCIONES DE SELECCIÓN.................................................................................... 25
IF .................................................................................................................................. 25 SWITCH........................................................................................................................ 25
4.2 INSTRUCCIONES DE ITERACIÓN .................................................................................... 26 FOR .............................................................................................................................. 26 WHILE.......................................................................................................................... 27 DO WHILE ................................................................................................................... 28
4.3 INSTRUCCIONES DE SALTO ........................................................................................... 28
Ing. Israel Durán Martínez 2
Facultad de Ingeniería Lenguaje C
return ............................................................................................................................ 28 break ............................................................................................................................. 29 continue ........................................................................................................................ 29
CAPÍTULO 5: FUNCIONES ..................................................................................... 30 5.1 FORMA GENERAL DE UNA FUNCIÓN.............................................................................. 30 5.2 PROTOTIPOS DE LAS FUNCIONES .................................................................................. 31 5.3 PARÁMETROS DE UNA FUNCIÓN ................................................................................... 31 5.4 ARGUMENTOS DE MAIN()............................................................................................. 34
CAPÍTULO 6: ARRAYS Y CADENAS................................................................... 36
6.1 ARRAYS UNIDIMENSIONALES....................................................................................... 36 6.2 CADENAS..................................................................................................................... 36 6.3 ARRAYS BIDIMENSIONALES ......................................................................................... 37
CAPÍTULO 7: PUNTEROS........................................................................................ 38 7.1 ¿QUÉ SON LOS PUNTEROS?........................................................................................... 38 7.2 DECLARACIÓN DE APUNTADORES ................................................................................ 38
CAPÍTULO 8: ESTRUCTURAS ............................................................................... 41
CAPÍTULO 9: ARCHIVOS ........................................................................................ 42 7.1 EL PUNTERO A ARHIVO ................................................................................................ 42 7.2 APERTURA DE UN ARCHIVO ......................................................................................... 42
BIBLIOGRAFÍA ............................................................................................................ 44
Ing. Israel Durán Martínez 3
Facultad de Ingeniería Lenguaje C
CAPÍTULO 1: INTRODUCCIÓN AL LENGUAJE C
1.1 Orígenes del lenguaje C
El lenguaje C fue inventado e implementado por primera vez por Dennis Ritchie
en DEC PDP-11 usando UNIX como sistema operativo. C es el resultado de un proceso
de desarrollo comenzando con un lenguaje anterior denominado BCPL. BCPL fue
desarrollado por Martín Richards e influenció otro lenguaje denominado B, inventando
por Ken Thompson, que en los años sesenta llevó al desarrollo del C.
Durante muchos años el estándar de C fue realmente la versión proporcionada
con la versión V del sistema operativo UNIX. Aparece descrito en el libro The C
Programming Language de Brian Kernighan y Dennis Ritchie. Con la popularidad de las
microcomputadoras se crearon muchas implementaciones de C. En lo que se podría
decir que era un milagro, los códigos fuente aceptados por la mayoría de esas
implementaciones eran altamente compatibles. Sin embargo, como no existía ningún
estándar, aparecieron discrepancias. Para remediar la situación, el Instituto Nacional
de Estándares Americano (ANSI) estableció un comité a principios del verano de 1983
para crear un estándar que definiera de una vez por todas el lenguaje C. Finalmente,
el estándar fue adoptado en diciembre de 1989, comenzando a estar disponibles las
primeras copias a principios de 1990. El estándar también fue adoptado por la ISO
(Organización Internacional de Estándares), siendo habitual que el estándar se refiera
como estándar ANSI/ISO.
Durante los años noventa, el desarrollo del estándar de C++ acaparó casi toda
la atención de los programadores. Sin embargo, el trabajo sobre C continuó, siendo
desarrollado un nuevo estándar terminado en 1999 y que comúnmente se le llama
C99. En general, C99 mantiene prácticamente todas las características de C89.
1.2 Un lenguaje de nivel medio
A menudo se denomina al lenguaje C como un lenguaje de computadora de
nivel medio. Esto no significa que sea menos potente, más difícil de usar o menos
evolucionado que lenguajes de alto nivel como BASIC o Pascal; ni implica que C sea
Ing. Israel Durán Martínez 4
Facultad de Ingeniería Lenguaje C
similar al lenguaje ensamblador y por tanto presente al usuario sus problemas
asociados. C se presenta como un lenguaje de nivel medio porque combina elementos
de lenguajes de alto nivel con la funcionalidad del lenguaje ensamblador.
Como lenguaje de nivel medio, C permite la manipulación de bits, bytes y
direcciones – los elementos básicos con los que funciona la computadora-. El código de
C es muy portable.
Todos los lenguajes de alto nivel soportan el concepto de tipos de datos. Un tipo
de datos define un conjunto de valores que pueden tener una variable junto con un
conjunto de operaciones que se pueden realizar sobre esa variable. Algunos tipos de
datos comunes son los enteros, los caracteres y los reales. Aunque el lenguaje C tiene
cinco tipos de datos básicos incorporados, no se trata de un lenguaje fuertemente
tipificado en el sentido de Pascal o Ada. C permite casi todas las conversiones de tipos.
Por ejemplo, los tipos entero y de carácter pueden ser entremezclados libremente en la
mayoría de las expresiones. C no lleva a cabo la comprobación de errores en el tiempo
de ejecución como pueden ser el sobrepasar los límites de los arrays o la
compatibilidad de tipos de los argumentos. Esas comprobaciones quedan enteramente
como responsabilidad del programador.
1.3 Un lenguaje estructurado
El lenguaje C se denomina normalmente lenguaje estructurado, ya que tiene
similitudes estructurales con ALGOL, Pascal y Modula-2. Técnicamente, un lenguaje
estructurado en bloques permite declarar procedimientos o funciones dentro de otros
procedimientos o funciones. De esta forma, se extienden los conceptos de globalidad y
localidad mediante el uso de reglas de alcance, que gobiernan la visibilidad de las
variables o de los procedimientos. Dado que C no permite la creación de funciones
dentro de funciones, no puede ser formalmente denominado lenguaje estructurado en
bloques.
La característica distintiva de un lenguaje estructurado es la
compartimentalización de código y datos. Se trata de la capacidad de un lenguaje de
seccionar y esconder el resto del programa toda la información y las instrucciones
necesarias para llevar a cabo una determinada tarea. Una forma como se consigue la
Ing. Israel Durán Martínez 5
Facultad de Ingeniería Lenguaje C
compartimentalización es mediante el uso de subrutinas que empleen variables locales.
Con el uso de variables locales es posible escribir subrutinas de forma que lo que
ocurra en su interior no provoque efectos secundarios en otras partes del programa.
Esta posibilidad hace que sea muy fácil que los programas en C compartan secciones
de código. Al desarrollar funciones compartimentalizadas sólo es necesario conocer que
es lo que la función hace, no cómo lo hace. El excesivo uso de variables globales puede
hacer que los errores proliferen en el programa, al permitir los efectos secundarios no
deseados.
La componente estructural principal de C es la función; una subrutina
independiente. En C, las funciones son los bloques constitutivos en los que se
desarrolla toda la actividad de los programas. Son las que permiten definir las tareas
de un programa y codificarlas por separado, permitiendo así que los programas sean
modulares. Una vez que se ha creado una función se puede aprovechar funcionando
perfectamente en distintas situaciones, sin crear efectos secundarios en otras partes
del programa. El hecho de poder crear funciones independientes es algo
extremadamente crítico en grandes proyectos donde es importante que el código de un
programador no afecte accidentalmente al de otro.
Otra forma de estructuración y compartimentalización de código en C viene
dada por el uso de bloques de código. Un bloque de código es un grupo de
instrucciones de un programa conectadas de forma lógica que es tratado como una
unidad. En C se crean bloques de código colocando una serie de instrucciones entre
llaves.
Ejemplo:
if(x < 10) { printf(“Demasiado bajo \n”); }
1.4 Compiladores frente a intérpretes
Los términos compilador e intérprete se refieren a la forma en que se ejecuta
un programa. En teoría, cualquier lenguaje de programación puede ser compilado o
interpretado, pero algunos se suelen ejecutar en una forma o en la otra. Por ejemplo,
Java fue diseñado para ser interpretado y C para ser compilado. La forma en que se
Ing. Israel Durán Martínez 6
Facultad de Ingeniería Lenguaje C
ejecuta un programa no viene definida por el lenguaje en que se haya escrito. Los
intérpretes y los compiladores con simplemente programas que trabajan sobre el
código fuente del programa.
Un intérprete lee el código fuente de un programa línea a línea, realizando las
instrucciones específicas contenidas en esa línea. Un compilador lee el programa
entero y lo convierte en código objeto, que es una traducción del código fuente del
programa a una forma que puede ser ejecutada directamente por la computadora. El
código objeto también se suele denominar código binario o código máquina. Una vez
que el programa está compilado las líneas del código fuente dejan de tener sentido en
la ejecución del programa. Cuando se usa un intérprete, el código fuente debe estar
presente cada vez que se quiere ejecutar el programa. Por el contrario, un compilador
convierte el programa en código objeto que puede ser directamente ejecutado por la
computadora. Como el compilador traduce el programa de una vez, todo lo que hay
que hacer es ejecutarlo directamente, normalmente mediante el simple proceso de
escribir su nombre. Por tanto, la compilación sólo cuesta una vez, mientras que el
código interpretado lleva esa carga cada vez que se ejecuta un programa.
1.5 La biblioteca y el enlazado
Técnicamente hablando, es posible crear un programa en C que sea funcional y
útil y que consista solamente en las sentencias realmente creadas por el programador.
Sin embargo, esto es bastante raro, ya que C no proporciona, dentro de la definición
real del lenguaje, ningún método para llevar a cabo las operaciones de entrada/salida.
Por ello la mayoría de los programadores incluyen llamadas a varias funciones
contenidas en la biblioteca estándar del lenguaje C.
Las funciones que se encuentran en la biblioteca lo están en formato reubicable.
Esto significa que las direcciones de memoria de las diferentes instrucciones de código
máquina no han sido definidas de forma absoluta; solo se mantiene información sobre
desplazamientos. Cuando se enlaza un programa con funciones de la biblioteca
estándar, se usan esos desplazamientos de memoria para definir las direcciones
reales.
1.6 Entornos de desarrollo
Ing. Israel Durán Martínez 7
Facultad de Ingeniería Lenguaje C
La mayoría de los compiladores modernos se proporcionan en dos formas. La
primera forma es el compilador autónomo de línea de órdenes. Con esta forma se
utiliza un editor aparte para crear los programas, luego se compila el programa y,
finalmente, se ejecuta el programa. Esto se lleva a cabo mediante órdenes
independientes dadas en la línea de comandos. Esta es la forma tradicional de
implementación de los compiladores.
La segunda forma de un compilador se encuentra en un entorno integrado de
desarrollo (IDE), como Visual C++ o Dev C++. En esta forma, el compilador esta
integrado con un editor, un depurador, un administrador de proyectos y un sistema de
soporte para tiempo de ejecución. Con un IDE se edita, compila y ejecuta el programa
sin salir del entorno. Actualmente los IDEs que distribuyen los principales fabricantes
de compiladores tienen mucho que ofrecer a los programadores. Si se emplea un poco
de tiempo en ajustar las opciones del entorno para que esté optimizado a las
necesidades propias, se puede comprobar que el uso del IDE ayuda mucho en el
proceso de desarrollo.
Ing. Israel Durán Martínez 8
Facultad de Ingeniería Lenguaje C
CAPÍTULO 2: LENGUAJE C: ELEMENTOS BÁSICOS
2.1 Estructura general de un programa en C
Todos los programas en C consisten en uno o más módulos llamados funciones.
La única función que debe estar absolutamente presente es la denominada main(),
siendo la primera función que es llamada cuando comienza la ejecución del programa.
En código C bien escrito, main() en esencial, esboza lo que el programa hace. Ese
esbozo está compuesto por llamadas a funciones. Aunque técnicamente main() no es
una palabra clave, se le trata como si lo fuera. No se debe usar main() como nombre
para una variable ya que el compilador se confundirá.
La forma general de un programa en C se muestra a continuación:
Directivas del preprocesador Prototipos de funciones
Declaraciones globales /*Función main*/
int main(void) { variables locales sentencias llamadas a funciones } /*Funciones definidas por el usuario*/ f1() { variables locales sentencias secuencia de sentencias } f2() { variables locales sentencias secuencia de sentencias } . . . fN() { variables locales sentencias secuencia de sentencias }
Ing. Israel Durán Martínez 9
Facultad de Ingeniería Lenguaje C
2.1.1 Directivas del preprocesador
El preprocesador consta de directivas que son instrucciones al compilador.
Todas las directivas del preprocesador comienzan con el signo de libro o de
<<almohadilla>> (#) y no terminan en punto y coma, ya que son instrucciones del
lenguaje C.
La directiva #include indica al compilador que lea el archivo fuente (archivo
cabecera o de inclusión) que viene a continuación de ella y su contenido lo inserte en
la posición donde se encuentra dicha directiva. Estas instrucciones son de la forma
#include <nombrearchivo.h> o bien #include “nombrearchivo.h”.
La directiva #define indica al preprocesador que defina un ítem de datos u
operación para el programa C. Por ejemplo, la directiva #define TAM 10 sustituirá el
valor de 10 cada vez que TAM aparezca en el programa.
2.1.2 Declaraciones globales Las declaraciones globales indican al usuario que las constantes o variables así
declaradas son comunes a todas las funciones de su programa. Se sitúan antes de la
función main( ). La zona de declaraciones globales puede incluir declaraciones de
variables además de declaraciones de prototipos de función.
2.1.3 Función main( )
Cada programa C tiene una función main( ) que es un punto inicial de entrada
al programa. Su estructura es:
int main() { . . . Bloque de sentencias return 0; }
2.1.4 Funciones definidas por el usuario
Un programa C es una colección de funciones. C proporciona funciones
predefinidas que se denominan funciones de biblioteca y otras definidas por el usuario.
Ing. Israel Durán Martínez 10
Facultad de Ingeniería Lenguaje C
Se invocan por su nombre y los parámetros opcionales que tenga. Después de que la
función sea llamada, el código asociado con la función se ejecuta y, a continuación, se
retorna a la función llamadora. En C, las funciones definidas por el usuario requieren
una declaración o prototipo en el programa, que indica al compilador el nombre por el
que ésta será invocada.
#include<stdio.h> //Prototipo de la función void prueba(); int main() { prueba(); return 0; } //Función definida por el usuario void prueba() { printf(“Mis primeros pasos \n”); } Ejemplo: Mi primer programa en C
Comentario: Todos los programas están compilados en Dev C++
/*Directivas del preprocesador*/ #include<stdio.h> /*Prototipos de funciones*/ void hola(void); /*Función main*/ int main(void) { printf("Mi primer programa en C\n"); hola(); getchar(); return 0; } /*Funciones definidas por el usuario*/ void hola(void) { printf("Hola a todos\n"); }
2.2 Comentarios
Ing. Israel Durán Martínez 11
Facultad de Ingeniería Lenguaje C
Los comentarios de una sola línea comienzan con // y terminan al final de la
línea. Por ejemplo:
//Este es un comentario de una sola línea
Los comentarios multilínea empiezan con un /* y terminan con */. No debe
haber espacios entre el asterisco y la barra. El compilador ignora cualquier texto entre
los símbolos de comienzo y fin de comentario.
Los comentarios multilínea no se pueden anidar. Es decir, un comentario no
puede contener otro comentario. Por ejemplo:
/* Comentario externo
/*Comentario interno que provoca un error*/
*/
2.3 Identificadores
Los nombres usados para referirse a las variables, funciones, las etiquetas y
otros objetos definidos por el usuario se conocen como identificadores. El primer
carácter debe ser una letra o un símbolo de subrayado y los caracteres siguientes
pueden ser letras, números o símbolos de subrayado.
En C las minúsculas y las mayúsculas se tratan como distintas. Así, cuenta,
Cuenta y CUENTA son tres identificadores distintos. Además de que un identificador no
puede ser igual que una palabra clave y no debe tener el nombre de una función ya
escrita.
Ejemplo:
a) Identificadores válidos
X y21 suma_1 _temperatura
nombres area porc_imp TABLA
b) Identificadores no válidos
4num El primer carácter debe ser letra.
“x” Caracteres ilegales (“)
orden-no Carácter ilegal (-)
indicador error Carácter ilegal (espacio en blanco)
Ing. Israel Durán Martínez 12
Facultad de Ingeniería Lenguaje C
Convenciones
• Los identificadores deben ser descriptivos: deben hacer referencia al significado
de aquello a lo que se refieren.
int n1, n2 //MAL
int anchura, altura; //BIEN
• Los identificadores asociados a las variables se suelen poner en minúsculas
int ConTADoR; //MAL
int contador; //BIEN
• Cuando el identificador está formado por varias palabras, la primera palabra va
en minúsculas y el resto de palabras se inician con una letra mayúscula (o bien
se separan las distintas palabras por guiones de subrayado.
int mayorvalor; //MAL
int mayor_valor; //BIEN
int mayorValor; //BIEN
2.4 Palabras reservadas
Las siguientes palabras no pueden usarse como identificadores, es decir, no
debe servir como nombre de variable o de función.
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
Todas las palabras van en minúsculas.
2.5 Tipos de datos
Ing. Israel Durán Martínez 13
Facultad de Ingeniería Lenguaje C
Existen cinco tipos de datos atómicos en C: carácter, entero, coma flotante,
coma flotante de doble precisión y sin valor
Tipo Tamaño en bytes Rango
char 1 -128 a 127
int 2 -32768 a 32767
float 4 1.17549e–38 a 3.40282e+38
double 8 2.22507e–308 a 1.79769e+308
void 0 Sin valor
Los valores de tipo char se usan normalmente para guardar valores definidos en
el juego de caracteres ASCII, así como cualquier cantidad de 8 bits. Las variables de
tipo int se usan para guardar cantidades enteras. Las variables de tipo float o double
se usan para guardar números reales.
El tipo void tiene tres usos. El primero es para declarar explícitamente una
función como que no devuelve valor alguno; el segundo es para declarar
explícitamente una función sin parámetros; el tercero es para crear punteros
genéricos.
Modificadores de tipos
A excepción del tipo void, los tipos de datos básicos pueden tener distintos
modificadores precediéndolos. Un modificador se usa para alterar el significado del tipo
base para que se ajuste más precisamente a las necesidades de cada momento. A
continuación se muestra la lista de modificadores:
• signed – Aplicable a los tipos char, short, int y long.
• unsigned – Aplicable a los tipos char, short, int y long.
• long
• short
Los modificadores signed, unsigned, short y long se pueden aplicar a los tipos
base entero y de carácter. Sin embargo, long también se puede aplicar a double.
Tipo Tamaño en bytes Rango
Ing. Israel Durán Martínez 14
Facultad de Ingeniería Lenguaje C
char 1 -128 a 127
unsigned char 1 0 a 255
signed char 1 -128 a 127
int 2 o 4 -32,768 a 32,767
unsigned int 2 o 4 0 a 65,535
signed int 2 o 4 Igual que int
short int 2 -32,768 a 32,767
unsigned short int 2 0 a 65,535
signed short int 2 Igual que short int
long int 4 -2,147,483,648 a 2,147,483,647
long long int 8 -(263-1) a 263-1 (Para C99)
signed long int 4 Igual que long int
unsigned long int 4 0 a 4,294,967,295
unsigned long long int 8 0 a 264-1 (Para C99)
float 4 1.17549e–38 a 3.40282e+38
double 8 2.22507e–308 a 1.79769e+308
long double 10 o 12 3.4e–4932 a 1.2e+4932
limits.h
Librería que contiene parámetros de entorno, información sobre limitaciones y
rangos para tipos enteros.
Constante Significado
CHAR_BIT Número de bits del tipo char
CHAR_MIN Valor mínimo del tipo char
CHAR_MAX Valor máximo del tipo char
INT_MIN Valor mínimo del tipo int
INT_MAX Valor máximo del tipo int
LONG_MIN Valor mínimo del tipo long
LONG_MAX Valor máximo del tipo long
SCHAR_MIN Valor mínimo del tipo char con signo
SCHAR_MAX Valor máximo del tipo char con signo
SHRT_MIN Valor mínimo del tipo short
SHRT_MAX Valor máximo del tipo short
UCHAR_MAX Valor máximo de unsigned char
USHRT_MAX Valor máximo unsigned short
UINT_MAX Valor máximo unsigned int
Ing. Israel Durán Martínez 15
Facultad de Ingeniería Lenguaje C
ULONG_MAX Valor máximo unsigned long
2.6 Variables
Una variable es una posición de memoria con nombre que se usa para
mantener un valor que puede ser modificado por el programa. Todas las variables han
de estar declaradas antes de poder ser utilizadas. La forma general de la declaración
es:
tipo lista_de_variables;
• tipo - debe ser un tipo de datos válido con algún modificador.
• lista_de_variables - puede consistir en uno o más nombres de identificadores
separados por comas.
2.6.1 Variables locales
Las variables locales son aquellas que se declaran dentro de una función. Este
tipo de variables pueden ser utilizadas sólo en las instrucciones que estén dentro del
bloque en el que han sido declaradas. Un bloque de código comienza con una llave de
apertura y termina con una llave de cierre.
Las variables locales sólo existen mientras se está ejecutando el bloque de
código en el que son declaradas. O sea, la variable local se crea al entrar en el bloque
y se destruye al salir de él. Más aún, una variable declarada dentro de un bloque de
código no tiene que ver con otra variable con el mismo nombre que se haya declarado
en otro bloque de código distinto.
Ejemplo: Variables locales
#include<stdio.h> int main() { /*Declaración de una variable local*/ int x=10; if(x == 10) { /*Declaración de una variable local. Pierde su valor cuando sale de este bloque*/ int x; x=99; printf("x interna: %d\n",x);
Ing. Israel Durán Martínez 16
Facultad de Ingeniería Lenguaje C
} printf("x externa: %d\n",x); getchar(); return 0; }
2.6.2 Variables globales
Las variables globales se conocen a lo largo de todo el programa y se pueden
usar en cualquier parte del código. Además, mantienen sus valores durante toda la
ejecución del programa. Las variables globales se crean al declararlas en cualquier
parte fuera de la función. Pueden ser accedidas por cualquier expresión,
independientemente de la función en la que se encuentre la expresión.
Si una variable global y una variable local tienen el mismo nombre, todas las
referencias a ese nombre de variable dentro de la función donde se ha declarado la
variable local se refieren a esa variable local y no tienen efecto sobre la variable global.
Ejemplo: Variables globales
#include<stdio.h> //Declaracion de la variable global int cuenta; //Prototipo de la funcion void funcion1(void); int main(void) { //Inicializa la variable global cuenta = 100; //Impresión de la variable global printf("Variable global cuenta: %d\n",cuenta); //Llamada a la función "funcion1()" funcion1(); //Impresión de la variable global printf("Variable global cuenta: %d\n",cuenta); getchar(); return 0; } //Creación de una función void funcion1(void) { //Declaracion de una variable local int cuenta = 20; printf("Variable local cuenta: %d\n", cuenta);
Ing. Israel Durán Martínez 17
Facultad de Ingeniería Lenguaje C
}
2.6.3 Inicialización de variables
Colocando el signo igual y una constante después del nombre de un variable se
puede dar a la mayoría de las variables un valor a la vez que se declaran. La forma
general de inicialización es:
tipo nombre_de_variable = valor;
Ejemplo: Inicialización de variables
#include<stdio.h> int main() { //Declaración e inicialización de variables char c = '&', c2; int y, x = 10; double d = 12.7655, d2; float f=2, f2; char cad[] = "Hola a todos"; //Impresión de las variables printf("Valor del caracter c: %c y c2: %c\n",c,c2); printf("Valor del entero x: %d e y: %d\n",x,y*2); printf("Valor del numero real f: %g y f2: %g\n",f,f2); printf("Valor del numero real d: %g y d2: %g\n",d,d2); printf("Valor del arreglo cad: %s\n",cad); getchar(); return 0; }
#include <stdio.h> #include <limits.h> #include <float.h> #include <stdlib.h> int main() { //Declaracion de variables char a=1; unsigned char e; int c, r1=33000; unsigned int r=33000; unsigned int g; short int b; unsigned short int f; long int d;
Ing. Israel Durán Martínez 18
Facultad de Ingeniería Lenguaje C
unsigned long int h; float i; double j; long double k; //Impresion del tama¤o de las variables en bytes printf("Longitud de cada uno de los tipos basicos (bytes)\n\n"); printf("La longitud de char a= %d\n",sizeof(a)); printf("La longitud de unsigned char e= %d\n",sizeof(e)); printf("La longitud de int c= %d\n",sizeof(c)); printf("La longitud de unsigned int g= %d\n",sizeof(g)); printf("La longitud de short int b= %d\n",sizeof(b)); printf("La longitud de unsigned short int f= %d\n",sizeof(f)); printf("La longitud de long int d= %ld\n",sizeof(d)); printf("La longitud de unsigned long int: %d\n",sizeof(h)); printf("La longitud de float: %d\n",sizeof(i)); printf("La longitud de double: %d\n",sizeof(j)); printf("La longitud de long double: %d\n",sizeof(k)); //Impresion del rango de algunos tipos de datos printf("\nValores minimos y maximos de cada uno de los tipos\n\n");
printf("Valores minimo y maximo de char: %d a %d\n",CHAR_MIN,CHAR_MAX);
printf("Valor maximo de unsigned char: %u\n",UCHAR_MAX);
printf("Valor minimo y maximo de int: %d a %d\n",INT_MIN,INT_MAX);
printf("Valor maximo de unsigned int: %u\n",UINT_MAX);
printf("Valor minimo y maximo de short int: %d a %d\n",SHRT_MIN,SHRT_MAX);
printf("Valor maximo de unsigned short int: %u\n",USHRT_MAX);
printf("Valor minimo y maximo de long int: %d a %d\n",LONG_MIN,LONG_MAX);
printf("Valor maximo de unsigned long int: %u\n",ULONG_MAX);
printf("Valor minimo y maximo de float: %g a %g\n",FLT_MIN,FLT_MAX);
printf("Valor minimo y maximo de double: %g a %g\n",DBL_MIN,DBL_MAX); getchar(); return (EXIT_SUCCESS); }
2.6.4 Constantes
Las constantes refieren valores fijos que no pueden ser modificados por el
programa. Pueden ser de cualquier tipo de datos básico. Para marcar que queremos
que una variable sea constante se utiliza la palabra reservada const y por convención
el nombre de la constante se escribe en mayúsculas.
const tipo NOMBRE_CONSTANTE = valor;
Ejemplo: Constantes
#include<stdio.h> /*Prototito de la función*/
Ing. Israel Durán Martínez 19
Facultad de Ingeniería Lenguaje C
void funcion1(void); /*Declaración de una constante global*/ const float PI=3.1415; int main() { const float PI = 3.1416; printf("Constante local (dentro del main): %f\n",PI); /*La expresión de abajo no es válida debido*/ /*a que a una constante no se le puede cambiar su valor*/ /*PI = 3.1415;*/ if(4) { const float PI= 3.14; printf("Constante local (dentro del if): %f\n",PI); } /*Llamada a la función*/ funcion1(); printf("Constante local (dentro del main): %f\n",PI); system("PAUSE"); } void funcion1(void) { /*Impresión de la constante global*/ printf("Constante Global PI = %f\n",PI); }
2.6.5 Constantes de carácter de barra invertida
Código Significado
\b Espacio atrás
\f Salto de página
\n Salto de línea
\r Retorno de carro
\t Tabulación horizontal
\” Comillas dobles
\’ Comilla simple
\\ Barra invertida
\v Tabulador vertical
\a Alerta
\? Signo de interrogación
\0N Constante octal (donde N es una constante octal)
Ing. Israel Durán Martínez 20
Facultad de Ingeniería Lenguaje C
\xN Constante hexadecimal (donde N es una constante hexadecimal)
Ing. Israel Durán Martínez 21
Facultad de Ingeniería Lenguaje C
CAPÍTULO 3: OPERADORES Y EXPRESIONES
C es un lenguaje muy rico en operadores incorporados. De hecho, dota de un
mayor significado a los operadores que la mayoría de los demás lenguajes de
computadora. Hay cuatro clases principales de operadores: aritméticos, relacionales,
lógicos y a nivel de bits
3.1 Operadores aritméticos
Operador Acción
- Resta, además de menos monario
+ Suma
* Multiplicación
/ División
% Módulo
-- Decremento
++ Incremento
3.2 Operadores relacionales y lógicos
En C, verdadero es cualquier valor distinto de cero. Falso es cero. Las
expresiones que utilizan los operadores relacionales y lógicos devuelven 1 para cierto y
0 para falso.
Operadores relacionales
Operador Acción
> Mayor que
>= Mayor o igual que
< Menor que
<= Menor o igual que
== Igual
Ing. Israel Durán Martínez 22
Facultad de Ingeniería Lenguaje C
!= Distinto
Operadores lógicos
Operador Acción
&& Y
|| O
! NO
Tabla de verdad
p q p && q p || q !p p^q
0 0 0 0 1 0
0 1 0 1 1 1
1 0 0 1 0 1
1 1 1 1 0 0
3.3 Operadores a nivel de bits
Dado que C se diseñó para sustituir al lenguaje ensamblador en muchas tareas
de programación, era importante permitir todas las operaciones que se pueden realizar
en ensamblador. Las operaciones a nivel de bits se refieren a la comprobación,
asignación o desplazamiento de los bits reales que componen un byte o una palabra,
que corresponden a los tipos estándar char e int con sus variantes. Estas operaciones
no se pueden usar sobre float, double, long, double, void u otros tipos más complejos.
Operador Acción
& Y
| O
^ O exclusiva(XOR)
~ Complemento a uno
>> Desplazamiento a la derecha
Ing. Israel Durán Martínez 23
Facultad de Ingeniería Lenguaje C
>> Desplazamiento a la izquierda
3.4 Precedencia de los operadores de C
Mayor () [] -> .
! ~ ++ -- - (tipo) * & sizeof
* / %
+ -
<< >>
< <= > >=
== !=
&
^
|
&&
||
?:
= += -= *= /=
Menor ,
Ing. Israel Durán Martínez 24
Facultad de Ingeniería Lenguaje C
CAPÍTULO 4: INSTRUCCIONES DE CONTROL
4.1 Instrucciones de selección
IF
La forma general de la instrucción if es:
if(expresión) { instrucciones; } else { instrucciones; }
donde la cláusula else es opcional.
Si la expresión es cierta (cualquier valor que no sea 0), se ejecuta la instrucción
o el bloque de instrucciones que constituye el objetivo del if; en caso contrario se
ejecuta la instrucción o el bloque de instrucciones que constituyen el objetivo de else,
si existe. Sólo se ejecuta el código asociado al if o al else, nunca ambos.
SWITCH
C incorpora una instrucción de selección múltiple, denominada switch, que
compara sucesivamente el valor de una expresión con una lista de constantes enteras
o de caracteres. Cuando se encuentra una correspondencia, se ejecutan las
instrucciones asociadas con la constante. La forma general de la instrucción switch es:
switch(expresion) { case constante1: secuencia de instrucciones break; case constante2: secuencia de instrucciones break; case constante3: secuencia de instrucciones
Ing. Israel Durán Martínez 25
Facultad de Ingeniería Lenguaje C
break; . . . default: secuencia de instrucciones }
La expresión debe dar como resultado un valor entero. Por tanto, se pueden
utilizar valores enteros o de carácter, mientras que las expresiones reales en coma
flotante, no están permitidas. Se comprueba el valor de la expresión, por orden, con
los valores de las constantes especificadas en las instrucciones case. Cuando se
encuentra una correspondencia, se ejecuta la secuencia de instrucciones asociada con
ese case, hasta que se encuentra la instrucción break o el final de la instrucción switch.
La instrucción default se ejecuta si no se ha encontrado ninguna correspondencia. La
instrucción default es opcional y si no está presente no se ejecuta ninguna acción al
fallar todas las comprobaciones.
La instrucción break es una de las instrucciones de salto de C. Se puede usar en
bucles además de en la instrucción switch. Cuando se encuentra un break en una
instrucción switch, la ejecución del programa salta a la línea de código que sigue a la
instrucción switch.
Hay tres cosas importantes que se deben saber sobre la instrucción switch:
• La instrucción switch se diferencia de la instrucción if en que switch sólo puede
comprobar la igualdad, mientras que if puede evaluar expresiones relacionales
o lógicas.
• No puede hacer dos constantes case en el mismo switch que tengan los mismos
valores.
• Si se utilizan constantes de tipo carácter en la instrucción switch, se convierten
automáticamente a sus valores enteros.
4.2 Instrucciones de iteración
FOR
Ing. Israel Durán Martínez 26
Facultad de Ingeniería Lenguaje C
El formato general del bucle for de C se encuentra de una forma u otra en todos
los lenguajes de programación procedimentales. En C, sin embargo, proporciona una
potencia y flexibilidad sorprendentes.
La forma general para la instrucción for es:
for(inicialización;condición;incremento) { instrucciones;
}
El bucle for admite muchas variantes. Sin embargo, la inicialización
normalmente es una instrucción de asignación que se utiliza para iniciar la variable de
control del bucle. La condición es una expresión relacional que determina cuándo
finaliza el bucle. El incremento define cómo cambia la variable de control cada vez que
se repite el bucle. Estas tres secciones principales deben estar separadas por punto y
coma. El bucle for continúa ejecutándose mientras que la condición sea cierta. Una vez
que la condición se hace falta, la ejecución del programa continúa por la instrucción
siguiente al for.
En los bucles for, la prueba de la condición se hace siempre al principio del
bucle. Esto supone que el código dentro del bucle puede no ejecutarse si la condición
es falsa al comienzo
WHILE
El segundo bucle disponible en C es el bucle while. Su forma general es:
while(condición) { instrucciones;
}
La condición puede ser cualquier expresión y cualquier valor distinto de 0 es
cierto. El bucle itera mientras la condición es cierta. Cuando la condición se hace falta,
el control del programa pasa a la línea inmediatamente siguiente al código del bucle.
Ing. Israel Durán Martínez 27
Facultad de Ingeniería Lenguaje C
DO WHILE
A diferencia de los bucles for y while, que analizan la condición del bucle al
principio, el bucle do-while comprueba la condición al final. Esto significa que el bucle
do while siempre se ejecuta al menos una vez. La forma general del bucle do while es:
do { instrucciones;
} while(condición);
Aunque las llaves no son necesarias cuando sólo hay una instrucción, se utilizan
normalmente para evitar confusiones con el while. El bucle itera hasta que la condición
se hace falsa.
4.3 Instrucciones de salto
C tiene cuatro instrucciones que llevan a cabo un salto incondicional: return,
goto, break y continue. De ellas se pueden usar return y goto en cualquier parte
dentro de una función. Las instrucciones break y continue se usan junto con
instrucciones de bucle y además también se puede usar break junto con switch.
return
La función return se usa para volver de una función. Se trata de una instrucción
de salto porque hace que la ejecución vuelva al punto en que se hizo la llamada a la
función. Un return puede tener o no un valor asociado. Sólo se puede utilizar un return
con un valor asociado en una función con valor de vuelta de tipo distinto de void. En
ese caso, el valor asociado con return es el valor de vuelta de la función. Un return sin
valor de vuelta se utiliza para volver de las funciones de tipo void.
La forma general de la instrucción return es:
return expresión;
Ing. Israel Durán Martínez 28
Facultad de Ingeniería Lenguaje C
La expresión estará presente sólo si se ha declarado la función como
devolviendo un valor. En este caso, el valor de la expresión se convertirá en el valor
devuelto por la función.
Se pueden usar tantas instrucciones return como se quiera en una función. Sin
embargo, la función termina tan pronto como encuentra el primer return. La llave }
que termina el código de la función también hace que se vuelva de ella. Equivale a un
return sin valor específico. Si esto ocurre en una función declarada de un tipo distinto
de void, entonces el valor de vuelta de la función queda indeterminado.
Una función declarada como void no puede contener una instrucción return que
especifique un valor. Dado que las funciones void no devuelven valor, parece lógico
que no contengan ninguna instrucción return que devuelva un valor.
break
La instrucción break tiene dos usos. Se puede usar para finalizar un case en una
instrucción switch. También se puede usar para forzar la terminación inmediata de un
bucle, saltando la evaluación condicional normal del ciclo.
Cuando se encuentra la instrucción break dentro de un bucle, el bucle finaliza
inmediatamente y el control pasa a la instrucción que sigue al bucle.
continue
La instrucción continue funciona de una forma algo similar al break. Sin
embargo, en vez de forzar la terminación, continue fuerza una iteración del bucle y
salta cualquier código que exista entre medias. Para el bucle for, continue hace que se
ejecuten las partes de prueba condicional y de incremento del bucle. Para los bucles
while y d
Ing. Israel Durán Martínez 29
Facultad de Ingeniería Lenguaje C
CAPÍTULO 5: FUNCIONES
Las funciones son bloques constructores de C y el lugar donde se produce toda la
actividad del programa. Las funciones contienen varias sentencias bajo un solo
nombre, que un programa puede utilizar una o más veces para ejecutar dichas
sentencias. Las funciones ahorran espacio, reduciendo repeticiones y haciendo más
fácil la programación, proporcionando un medio de dividir un proyecto grande en
módulos pequeños más manejables. La división del código en funciones hace que las
mismas se puedan reutilizar en su programa y en otros programas.
5.1 Forma general de una función
La forma general de una función es:
tipo_dato_retorno nombreFunción(lista de parámetros)
{
cuerpo de la función
return expresión;
}
El tipo de dato de retorno especifica el tipo de dato que devuelve la función.
Una función puede devolver cualquier tipo de dato excepto un array. La lista de
parámetros es una lista de nombres separados por comas con sus tipos asociados. Los
parámetros reciben los valores de los argumentos cuando se llama a la función. Una
función puede no tener parámetros, en cuyo caso la lista de parámetros vacía se
puede especificar explícitamente como tal colocando la palabra clave void entre los
paréntesis.
En las declaraciones de variables se pueden declarar múltiples variables del
mismo tipo mediante una lista con los nombres de las variables separadas por comas.
En cambio, en las funciones todos los parámetros deben declararse individualmente,
incluyendo para cada uno tanto el tipo como el nombre.
f(tipo var1, tipo var2, …, tipo varN)
Ing. Israel Durán Martínez 30
Facultad de Ingeniería Lenguaje C
5.2 Prototipos de las funciones
La declaración de una función se denomina prototipo. Específicamente un prototipo
consta de los siguientes elementos: nombre de la función, una lista de parámetros
encerados entre paréntesis y un punto y coma. En C no es obligatorio incluir el
prototipo aunque sí es recomendable para que el compilador pueda hacer chequeos en
las llamadas a funciones. Los prototipos se sitúan normalmente al principio de un
programa, antes de la definición de la función main(). Cuando se usan prototipos, el
compilador puede encontrar e informar sobre conversiones de tipos ilegales entre el
tipo de los argumentos usados en la llamada a la función y las definiciones de tipos de
sus parámetros. El compilador también detectará diferencias entre el número de
argumentos usados en la llamada a la función y el número de parámetros de la misma.
5.3 Parámetros de una función
C siempre utiliza el método de parámetros por valor para pasar variables a funciones.
Para que una función devuelva un valor a través de un argumento hay que pasar la
dirección de la variable, y que el argumento correspondiente de la función sea un
puntero; es la forma de conseguir en C un paso de parámetros por referencia. C
permite utilizar punteros para implementar parámetros por referencia, ya que por
defecto, en C el paso de parámetros es por valor. Los parámetros por valor reciben
copias de los valores de los argumentos que se les pasan. La asignación a parámetros
por valor de una función no cambia el valor del argumento original pasado a los
parámetros. Los parámetros por referencia (declarados con *, punteros) reciben la
dirección de los argumentos pasados; a estos les debe preceder el operador &, excepto
los arrays. En una función, las asignaciones a parámetros por referencia (punteros)
cambian los valores de los argumentos originales. Con el objeto de añadir seguridad
adicional a las funciones, se puede añadir a la descripción de un parámetro la palabra
const, que indica al compilador que son sólo para pasar información al interior de la
función. Si se intenta modificar este parámetro se producirá un mensaje de error.
Ing. Israel Durán Martínez 31
Facultad de Ingeniería Lenguaje C
Ejemplos: Funciones
/* Calcula el factorial por medio de una función */ #include<stdio.h> /*Prototipo de la función*/ float factorial(int numero); int main(void) { int num; printf("Dame un numero para calcular el factorial: "); scanf("%d",&num); printf("\nEl factorial de %d es: %.1f",num,factorial(num)); fflush(stdin); getchar(); } /* Función que calcula el factorial*/ float factorial(int numero) { int i; float factorial = 1; for(i=1;i <= numero;i++) factorial = factorial * i; return factorial; }
/* Función que identifica si un número es primo Hace la suma de los primos comprendidos entre 1 y 100 */ #include<stdio.h> /*Prototipo de la función*/ char primo(int numero); int main() { int i, suma=0; for(i=1;i <= 100;i++) if(primo(i) == 's') suma = suma + i; printf("La suma de los números primos comprendidos\n"); printf("entre 1 y 100 es: %d",suma); getchar(); } /*Función que identifica si un número es o no primo*/
Ing. Israel Durán Martínez 32
Facultad de Ingeniería Lenguaje C
char primo(int numero) { int i; for(i=2;i < numero;i++) if(!(numero%i)) return 'n'; return 's'; }
/* Suma el valor ascii de los elementos de un arreglo de caracteres */ #include<stdio.h> /*Prototipo de la función*/ int sumaArreglo(char arr[]); int main() { char cadena[] = "Hola a todos"; printf("La suma de los respectivos ascii de la cadena es: %d",sumaArreglo(cadena)); getchar(); } /*Función que suma los elementos de un arreglo*/ int sumaArreglo(char arr[]) { int i, sumaAscii = 0; for(i=0;arr[i] != '\0';i++) sumaAscii = sumaAscii + arr[i]; return sumaAscii; }
/* Convierte cadena a mayúsculas */ #include<stdio.h> #include<ctype.h> /*Prototipo de la función*/ char *cadenaUpper(char *cadena); int main() { char *apuntadorCadena, cad[] = "Hola, como estan?"; int *ap; apuntadorCadena = cadenaUpper(cad); printf("%s",apuntadorCadena);
Ing. Israel Durán Martínez 33
Facultad de Ingeniería Lenguaje C
getchar(); } /* Función que convierte cadena a mayúsculas Paso de parámetros por referencia (apuntadores) La función regresa un apuntador a char */ char *cadenaUpper(char *cadena) { int i; for(i=0;*(cadena+i) != '\0';i++) if(!isupper(*(cadena+i))) *(cadena+i) = toupper(*(cadena+i)); return cadena; }
5.4 Argumentos de main()
Algunas veces resulta útil pasar información al programa cuando se ejecuta. El método
general es pasar información a la función main() mediante el uso de argumentos desde
la línea comandos. Un argumento de este tipo es la información que sigue al nombre
del programa en la línea de comandos del sistema operativo. Por ejemplo, cuando se
compila un programa, puede que se escriba algo como lo siguiente:
gcc nombrePrograma
donde nombrePrograma es el programa que se va a ejecutar.
Hay dos argumentos ya incorporados, argc y argv, que se utilizan para argumentos
desde la línea de comandos. El parámetro argc contiene el número de argumentos y es
un entero. Siempre vale 1 por lo menos, ya que el nombre del programa cuenta como
el primer argumento. El parámetro argv es un puntero a un array de punteros a
caracteres. Cada elemento del array apunta a un argumento de línea de comandos.
Todos los argumentos son cadenas; cualquier número tendrá que ser convertido
manualmente por el programa.
int main(int argc, char *argv[])
Ejemplo: Argumentos al main
#include<stdio.h>
Ing. Israel Durán Martínez 34
Facultad de Ingeniería Lenguaje C
int main(int argc, char *argv[]) { printf("Valor de argc: %d\n\n",argc); while(argc != 0) { printf("Argumento argv[%d]: %s\n",argc-1,argv[argc-1]); argc--; } getchar(); return 0; }
El programa anterior tiene el nombre de argumentosMain.c. Desde la línea de
comandos se compila de la siguiente manera:
gcc argumentosMain.c –o argumentosMain
y se ejecuta como:
argumentosMain uno dos tres
En donde uno, dos y tres son las cadenas pasadas al programa desde la línea de
comandos.
Ing. Israel Durán Martínez 35
Facultad de Ingeniería Lenguaje C
CAPÍTULO 6: ARRAYS Y CADENAS
Un array es una colección de variables del mismo tipo que se referencian por un
nombre común. A un elemento específico de un array se accede mediante un índice.
En C, todos los arrays constan de posiciones de memoria contiguas. La dirección más
baja corresponde al primer elemento y la dirección más alta al último elemento. Los
arrays pueden tener de una a varias dimensiones. El array más común es la cadena,
que simplemente es un array de caracteres terminado por un nulo.
6.1 Arrays unidimensionales
La forma general de declaración de un array unidimensional es:
tipo nombre_variable[tamaño];
Como en otros lenguajes, los arrays tienen que declararse explícitamente para
que así el compilador pueda reservar espacio de memoria para ellos. Aquí tipo declara
el tipo base del array, que es el tipo de cada elemento del array. El valor de tamaño
indica cuantos elementos mantendrá el array.
Ej. char cadena[10];
int n[5];
Un elemento se puede acceder indexando el nombre del array. Esto se hace
colocando el índice del elemento entre corchetes justo detrás del nombre del array.
Ej. cadena[2] = ‘s’; // Asigna el valor de ‘s’ al elemento 2 del arreglo.
En C, todos los arrays tienen el 0 como índice de su primer elemento.
6.2 Cadenas
El uso más común de los arrays unidimensionales, con mucho, es como cadenas
de caracteres. En C, una cadena es un array de caracteres terminado en nulo. Por
Ing. Israel Durán Martínez 36
Facultad de Ingeniería Lenguaje C
tanto, una cadena contiene los caracteres que la conforman seguidos de un nulo. La
cadena terminada en nulo es el único tipo de cadena definido en C.
C incluye una gran variedad de funciones de manipulación de cadenas. Algunas
de estas son:
Nombre Función
strcpy(c1,c2) Copia c2 en c1
strcat(c1,c2) Concatena c2 al final de c1
strlen(c1) Devuelve la longitud de c1
strcmp(c1,c2) Devuelve 0 si c1 y c2 son iguales; menor que 0 si c1 < c2; mayor que
0 si c1 > c2.
strchr(c1,car) Devuelve un puntero a la primera ocurrencia de car en c1
strstr(c1,c2) Devuelve un puntero a la primera ocurrencia de c2 en c1.
Estas funciones usan el archivo de cabecera estándar <string.h>.
6.3 Arrays bidimensionales
C admite arrays multidimensionales. La forma más simple de un array
multidimensional es el array bidimensional.
tipo_dato nombre_del_arreglo[r][c];
Ej. int x[3][4]; //Declaración de un arreglo bidimensional de 3 renglones y 4
columnas
Los arrays bidimensionales se almacenan en matrices fila-columna, en las que
el primer índice indica la fila y el segundo indica la columna.
Ing. Israel Durán Martínez 37
Facultad de Ingeniería Lenguaje C
CAPÍTULO 7: PUNTEROS
7.1 ¿Qué son los punteros?
Un puntero es una variable que contiene una dirección de memoria. Esa
dirección es la posición de otro objeto (normalmente otra variable) en memoria. Por lo
tanto se dice que si una variable (puntero) contiene la dirección de otra variable la
primera variable apunta a la segunda. Los punteros están muy relacionados con los
arrays y proporcionan una vía alternativa de acceso a los elementos individuales del
array.
Adicionalmente debemos de tomar en cuenta que dentro de la memoria de la
computadora, cada dato almacenado ocupa una o más celdas contiguas de memoria,
es decir, bytes adyacentes. El número de celdas de memoria requeridas para
almacenar un dato depende de su tipo. Por ejemplo, un carácter se almacenará
normalmente en un byte (8 bits) de memoria; un entero usualmente necesita 4 bytes
contiguos al igual que un tipo flotante; y una cantidad en doble precisión puede
requerir ocho bytes contiguos.
7.2 Declaración de apuntadores
Si una variable va a ser puntero, entonces antes de ser utilizada debe de
declararse como tal. Una declaración de puntero consiste en un tipo de dato, un * y el
nombre de la variable. Además, debe seguir las convenciones para nombres de
variables.
La sintaxis general de declaración es:
tipo_dato *nombreApuntador;
Ejemplos:
1. int *apunEntero;
2. float *apunReal;
Ing. Israel Durán Martínez 38
Facultad de Ingeniería Lenguaje C
3. char *apunCaracter;
El apuntador apunEntero es un apuntador a int, el tipo de dato del puntero
define el tipo de variables a las que puede apuntar el apuntador.
Los operadores de puntero
Hay dos operadores de punteros: & y *. & es un operador monario que devuelve la
dirección de memoria de su operando. Por ejemplo:
;&;,*10int
xapunEnteroapunEnterox=
=
pone en apunEntero la dirección de memoria en donde está almacenada la variable x .
Por lo tanto se puede pensar en el operador como devolviendo “la dirección de”. Por
lo tanto la instrucción de asignación anterior significa “ recibe la dirección
de
&apunEntero
x ”.
Para entender bien la asignación anterior, supongamos que la variable x utiliza
la posición de memoria AFFB para guardar el valor de 10. Entonces, después de la
asignación, apunEntero contiene el valor de AFFB.
El segundo operador de punteros, *, es el complemento de &. Es un operador
monario que devuelve el valor que se encuentra en la dirección que le sigue. Por
ejemplo,
#include<stdio.h>
int main()
{
int x=2,y=3;
int *apunEntero; /*Declaracion de un puntero tipo entero*/
/*Impresion de los valores de las variables*/
printf("x=%d, y=%d, apunEntero=%p\n\n",x,y,apunEntero);
Ing. Israel Durán Martínez 39
Facultad de Ingeniería Lenguaje C
apunEntero = &x; /*Se le asigna la dirección de x al puntero
apunEntero*/
/*Imprime los valores de las direcciones de memoria de x y el
apuntador. En
este caso son iguales*/
printf("Dir x: %p, Dir apuntador: %p\n\n",&x,apunEntero);
/*Se le asigna a y el valor localizado en la direccion del apuntador
apunEntero */
y = *apunEntero;
printf("x=%d, y=%d\n\n",x,y);
/*Se almacena el valor de 5 en la direccion de memoria de apunEntero*/
*apunEntero = 5;
printf("Lo que hay en la direccion %p:
%d\n\n",apunEntero,*apunEntero);
system("PAUSE");
}
Ing. Israel Durán Martínez 40
Facultad de Ingeniería Lenguaje C
CAPÍTULO 8: ESTRUCTURAS
Una estructura es una colección de variables que se referencia bajo un mismo nombre,
proporcionando un medio conveniente de mantener junta una información relacionada.
Una declaración de estructura forma una plantilla que puede utilizarse para crear
objetos estructuras (ejemplares de una estructura). Las variables que componen a la
estructura se llaman miembros de la estructura.
Ing. Israel Durán Martínez 41
Facultad de Ingeniería Lenguaje C
CAPÍTULO 9: ARCHIVOS
En C, un archivo puede ser cualquier cosa, desde un archivo de disco hasta una
terminal o una impresora. Mediante una operación de apertura se asocia una secuencia
con un archivo específico. Una vez que el archivo esta abierto, se puede intercambiar
información entre éste y el programa.
Cada secuencia asociada a un archivo tiene una estructura de control de tipo
FILE. La librería en donde se encuentran las funciones para manejar archivos es
<stdio.h>
7.1 El puntero a arhivo
El puntero a archivo es el hilo conductor que unifica el sistema de E/S de C. Un
puntero a archivo es un puntero a una estructura de tipo FILE. Apunta a información
que define varias cosas sobre el archivo, incluyendo su nombre, su estado y la posición
actual dentro de él. En esencia, el puntero a archivo identifica un archivo específico y
es utilizado por la secuencia asociada para dirigir el funcionamiento de las funciones de
E/S. Para leer o escribir sobre archivos, los programas tienen que utilizar punteros.
Para disponer de una variable puntero a archivo se utiliza una instrucción como esta:
FILE *arch;
7.2 Apertura de un archivo
La función fopen() abre una secuencia para que pueda ser utilizada y vincula un
archivo con la misma. Después devuelve el puntero al archivo asociado con ese
archivo. A menudo el archivo es un archivo de disco. La función fopne() tiene este
prototipo:
FILE *fopen(const char *nombre, const char *modo);
Ing. Israel Durán Martínez 42
Facultad de Ingeniería Lenguaje C
donde nombre es un puntero a una cadena de caracteres que representa un nombre
válido de archivo y puede incluir una especificación de ruta. La cadena a la que apunta
Ing. Israel Durán Martínez 43
Facultad de Ingeniería Lenguaje C
BIBLIOGRAFÍA
Ing. Israel Durán Martínez 44
Top Related