Facultad de Ingeniería - fenix.cichcu.unam.mxfenix.cichcu.unam.mx/PAYMN/Manuales/c/manualc.pdf ·...

-

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


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



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



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



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



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



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.



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 }



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.



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



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)



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



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



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



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);



} 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);



}

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;



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*/



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)



\xN Constante hexadecimal (donde N es una constante hexadecimal)



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



!= 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



>> Desplazamiento a la izquierda

3.4 Precedencia de los operadores de C

Mayor () [] -> .

! ~ ++ -- - (tipo) * & sizeof

* / %

+ -

<< >>

< <= > >=

== !=

&

^

|

&&

||

?:

= += -= *= /=

Menor ,



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



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



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.



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;



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



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)



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.



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*/



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);



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>



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.



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



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.



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;



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);



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");

}



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.



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);



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



BIBLIOGRAFÍA


Facultad de Ingeniería - fenix.cichcu.unam.mxfenix.cichcu.unam.mx/PAYMN/Manuales/c/manualc.pdf ·...

Documents

Transcript of Facultad de Ingeniería - fenix.cichcu.unam.mxfenix.cichcu.unam.mx/PAYMN/Manuales/c/manualc.pdf ·...