Lenguajes de Programacin IReferencia Marta Zorrilla Universidad de Cantabria

Ing. Santiago Esparza Guerrero Ingeniera en Computacin Unidad Acadmica de Ingeniera Elctrica

1

Introduccin al CObjetivos:Presentar la historia del lenguaje C y sus caractersticas principales. Presentar la estructura de un programa en C mediante ejemplos sencillos.

Contenidos:1. La historia del C. 2. Caractersticas. 3. Mi primer programa en C.

2

Historia del CMuchas ideas provienen de BCPL (Martin Richards, 1967) y de B (Ken Thompson, 1970). C fue diseado originalmente en 1972 para el SO UNIX en el DEC PDP-11 por Dennis Ritchie en los Laboratorios Bell. Primer Libro de referencia de C: The C Programming Language (1978) de Brian Kernighan y Dennis Ritchie. En los 80, gran parte de la programacin se realiza en C. En 1983 aparece C++ (orientado a objetos). En 1989 aparece el estndar ANSI C. En 1990 aparece el estndar ISO C (actual estndar de C). WG14 se convierte en el comit oficial del estndar ISO C. En dcada de los 90, WG14 trabaja en el estndar C9X/C99 que resuelve problemas de fiabilidad del ANSI C, amplia su funcionalidad con nuevos tipos de dato, funciones matemticas, arrays irrestringidos, etc.3

Caractersticas del CLenguaje de programacin de propsito general, muy adecuado para programacin de sistemas (unix fue escrito en C). Lenguaje relativamente pequeo: solo ofrece sentencias de control sencillas y funciones. La E/S no forma parte del lenguaje, sino que se proporciona a travs de una biblioteca de funciones. Permite la agrupacin de instrucciones. Programacin estructurada. Permite la separacin de un programa en mdulos que admiten compilacin independiente. Diseo modular. Programas portables.

4

Inconvenientes del CNo es un lenguaje fuertemente tipado. Es bastante permisivo con la conversin de datos. Sin una programacin metdica puede ser propenso a errores difciles de encontrar. La versatilidad de C permite crear programas difciles de leer.#define _ -F "); scanf("%s", cajas[registro].pieza); /* Leer el nmero de piezas. */ printf("Numero de piezas => "); scanf("%d", &cajas[registro].cantidad); /* Leer el precio de cada pieza. */ printf("Precio de cada pieza => "); scanf("%f", &cajas[registro].precio_unitario); /* Indicar que el registro tiene datos, V */ cajas[registro].existe = 'V'; registro ++; } while (registro < NUMCAJAS);

135

Cont./* Imprimir la informacin. */ for(registro = 0; registro < NUMCAJAS; registro++) { if(cajas[registro].existe == 'V') { printf("La caja %d contiene:\n", registro + 1); printf("Pieza => %s\n", cajas[registro].pieza); printf("Cantidad => %d\n", cajas[registro].cantidad); printf("Precio unitario => $%f\n", cajas[registro].precio_unitario); } } /* Fin for. */ } /*fin main*/

136

Paso de estructuras a funcionesUna funcin puede devolver una estructura. Se pueden pasar miembros individuales y estructuras completas a una funcin. Si la estructura es grande, el tiempo para copiar un estructura (paso por valor) es prohibitivo, por eso se aconseja pasarlo por referencia. Paso de miembros individualesstruct punto { float x; float y; }; void imprime_x (float x) { printf ("el valor de x %f", x); } /*llamada a funcin*/ imprime_x (p1.x);137

Paso de estructuras a funciones por valorEj.: leer y escribir una fecha.#include struct fecha { int dia; int mes; int anno; }; void imprimir_fecha(struct fecha f) { printf("Dia: %d\n", f.dia); printf("Mes: %d\n", f.mes); printf("Anno: %d\n", f.anno); return; } } main() { struct fecha fecha_de_hoy; fecha_de_hoy = leer_fecha(); imprimir_fecha(fecha_de_hoy); } struct fecha leer_fecha(void) { struct fecha f; printf("Dia: "); scanf("%d", &(f.dia)); printf("Mes: "); scanf("%d", &(f.mes)); printf("Anno: "); scanf("%d", &(f.anno)); return(f);

138

Paso de estructuras a funciones por referenciavoid leer_punto(struct punto *p); void imprimir_punto(struct punto p); struct punto { float x; float y; }; main() { struct punto p1; leer_punto(&p1); imprimir_punto(p1); }139

void leer_punto(struct punto *p) { printf("x = "); scanf("%f", &(p->x)); printf("y = "); scanf("%f", &(p->y)); } void imprimir_punto(struct punto p) { printf("x = %f\n", p.x); printf("y = %f\n", p.y); }

UnionesUna union contiene miembros cuyos tipos de datos pueden ser diferentes (igual que las estructuras). Su declaracin es similar a las estructuras:union nombre_estructura { tipoDato1 miembro_1; tipoDato2 miembro_2; . . tipoDatoN miembro_N; };

Todos los miembros que componen la union comparten la misma zona de memoria ahorro de memoria. Una variable de tipo union slo almacena el valor de uno de sus miembros.140

Ejemplo#include #include union numero { int entero; float real; }; main() { union numero num; /* leer un entero e imprimirlo */ printf("Entero: "); scanf("%d", &(num.entero)); printf("El entero es %d\n", num.entero); /* leer un real e imprimirlo */ printf("Real: "); scanf("%f", &(num.real)); printf("El entero es %f\n", num.real); }141

0

1

2entero real

3

Combinacin de datos estructurados: vector de estructuras y unionstruct ALUMNO { char grupo[15]; int asignat; char repite; }; struct PROFESOR { char nrp[16]; char cargo[21]; }; union AL_PR { struct ALUMNO al; struct PROFESOR pr; }; struct DATOS { char tipo; char nombre[40]; int edad; char direccion[40]; char telefono[15]; union AL_PR ambos; } personal[100];142Persona 1 Persona n Persona ...

El siguiente segmento de programa muestra los datos de la matriz personal.for (i = 0; i < 100; i++) { printf ("\nNombre: %s", personal[i].nombre); printf ("\nEdad: %d", personal[i].edad); printf ("\nDireccin: %s", personal[i].direccion); printf ("\nTelfono: %s", personal[i].telefono); if (personal[i].tipo == 'A') { printf ("\nALUMNO"); printf ("\nGrupo: %s", personal[i].ambos.al.grupo); printf ("\nN de Asignaturas: %d", personal[i].ambos.al.asignat); printf ("\nRepite: %d", personal[i].ambos.al.repite); } else { printf ("\nPROFESOR"); printf ("\nN.R.P.: %s", personal[i].ambos.pr.nrp); printf ("\nCargo: %s", personal[i].ambos.pr.cargo); } }

143

Tipos enumeradosUn tipo enumerado es similar a las estructuras. Sus miembros son constantes de tipo int. Es til definir nuevos literales paraAsociar un nombre a un valor numrico Limitar los valores que puede tomar una variable entera Hacer el cdigo ms legible

Definicin: enum nombre {m1, m2, ..., mN}; Ejemplo: enum color {negro, blanco, rojo};144

Ejemplo#include enum semaforo {rojo, amarillo, verde}; main() { enum estado semaforo; for(estado =rojo; estado 0) { getchar (); printf ("Nombre: "); gets (mireg.nombre); printf ("Edad: "); scanf ("%d", &mireg.edad); printf ("Altura: "); scanf ("%f", &mireg.altura); puntero = (num - 1) * sizeof (REGISTRO); if (fseek (f1, puntero, SEEK_SET)) puts ("Error de posicionamiento"); else { fwrite (&mireg, sizeof (mireg), 1, f1); if (ferror (f1)) { puts ("ERROR de escritura"); getch (); } } printf ("Escribir registro n: "); scanf ("%d", &num); } fclose (f1); } 179

Programacin modularTema 13

180

Tema 13Objetivos:Explicar el mbito de las variables del programa. Familiarizar al alumno con la creacin de programas modularizados y la creacin de libreras de funciones propias.

Contenidos:1. Variables globales y locales 2. Variables estticas 3. El preprocesador C: #include y #define. 4. Programas modulares 5. Bibliotecas de funciones

181

mbito de las variables y tipos de almacenamientoExisten dos formas de caracterizar una variable:Por su tipo de dato Por su tipo de almacenamiento

El tipo de dato se refiere al tipo de informacin que representa la variable (int, char, . . . ). El tipo de almacenamiento se refiere a su permanencia y a su mbito. El mbito de una variable es la porcin del programa en la cual se reconoce la variable. Segn el mbito, las variables pueden ser:Variables locales. Variables globales.

Segn el tipo, las variables pueden ser:Variables Variables Variables Variables automticas. estticas. externas. de tipo registro.

182

Variables globalesSe declaran fuera de las funciones y antes de su uso. Pueden ser accedidas desde cualquier funcin.#include void funcion1(void); int a = 1000; /* variable global */ main() { int b = 2; /* variable local */ funcion1(); printf("a = %d, b = %d \n", a, b); } void funcion1(void) { int c = 4; /* variable local */ printf("a = %d, c = %d \n", a, c); return; }183

Variables globales (y 2)Mantienen los valores que se les asignan en las funciones. Es mejor hacer uso de variables locales para evitar efectos secundarios o laterales.#include void funcion1(void); int a=10; /* variable global */ main() { printf("Antes a = %d\n", a); funcion1(); printf("Despues a = %d\n", a); } void funcion1(void) { a = 1000; return; }184

Variables localesLas variables locales que se definen en las funciones. Su mbito es local. Su vida se restringe al tiempo en el que esta activa la funcin. Los parmetros formales se tratan como variables automticas. Se pueden especificar con la palabra reservada auto aunque no es necesario.#include main() { auto int valor; /* equivalente a int valor */ valor = 5; printf("El valor es %d\n", valor); }

185

Variables estticasSu mbito es local a la funcin. Su vida coincide con la del programa retienen sus valores durante toda la vida del programa. Se especifican con static. #include void funcion(void); main() { funcion(); funcion(); funcion(); } void funcion(void) { static int veces = 0; veces = veces + 1; printf("Se ha llamado %d veces a funcion\n", veces); }

186

Variables de tipo registroInforman al compilador que el programador desea que la variable se almacene en un lugar de rpido acceso, generalmente en registros. Si no existen registros disponibles se almacenar en memoria. Se especifican con register#include main() { register int j; for (j = 0; j < 10; j++) printf("Contador = %d\n", j); }

187

Variables de tipo externasVariables globales. Hay que distinguir entre definicin y declaracin de variable externa. La definicin se escribe de la misma forma que las variables normales y reserva espacio para la misma en memoria. Una declaracin no reserva espacio de almacenamiento se especifica con extern. Se emplean cuando un programa consta de varios mdulos. En uno de ellos se define la variable. En los dems se declara (extern)

188

EjemploModulo principal (main.c) #include extern int valor; /* se declara */ void funcion(void); main() { funcion(); printf("Valor = %d\n", valor); } Modulo auxiliar (aux.c) int valor; /* se define la variable */ void funcion(void) { valor = 10; }

- Se compila por separado: gcc -c -Wall main.c gcc -c -Wall aux.c - Se obtienen dos mdulos objetos: main.o y aux.o. - El ejecutable (prog) se genera: gcc main.o aux.o -o prog

189

RecomendacionesEvitar el uso de variables globales. Mantener las variables lo ms locales que se pueda. Cuando se precise hacer accesible el valor de una variable a una funcin, se pasar como argumento.

190

MacrosUna macro es un identificador equivalente a una expresin, sentencia o grupo de sentencias. #include #define maximo(a,b) ((a > b) ? a : b) main() { int x, y; int max; printf("Introduzca dos numeros: "); scanf("%d %d", &x, &y); max = maximo(x,y); /* uso de la macro */ printf("El maximo es %d\n", max); }191

Macros (y 2)No puede haber blancos entre el identificador y el parntesis izquierdo. Una macro no es una llamada a funcin. El preprocesador sustituye todas las referencias a la macro que aparezcan dentro de un programa antes de realizar la compilacin:No se produce llamada a funcin mayor velocidad. Se repite el cdigo en cada uso de la macro mayor cdigo objeto.

192

Directiva #includeIndica al preprocesador que incluya un archivo fuente nom_fich. El formato es: #include "nom_fich" o bien, #include El uso de comillas dobles " " o ngulos < > indica dnde debe buscar el preprocesador el fichero nom_fich. comillas dobles " " : en el directorio de trabajo o en el camino absoluto que se especifique en la sentencia include ngulos < >: en los directorios donde se encuentran las bibliotecas que proporciona el compilador

193

Archivos de cabecera (.h)Permiten modularizar el cdigo y favorecer la ocultacin de informacin. Puede contener:Definiciones de macros #define MIL 1000 Declaraciones de variables extern int dia; Declaraciones de funciones extern void f(void); Otras directivas de inclusin #include a.h Comentarios Definiciones de tipos de dato (typedef)

Nunca debe tener:Definiciones de variables int dia; Definiciones de funciones void f(void);194

Compilacin prog. varios mdulospreprocesador leyOhm.h prog_ppal.c leyOhm.h prog_ppal.c prog_ppal.o enlazadorInclusin del archivo leyOhm.c

leyOhm.c

compilador

leyOhm.o

prog_ppal.exe195

La biblioteca de funcionesLENGUAJE ARCHIVO DE CABECERA ALLOC.H DESCRIPCIN Define funciones de asignacin dinmica de memoria

ANSI C C++

ASSERT.H BCD.H BIOS.H

Declara la macro de depuracin assert Define la clase bcd Define funciones utilizadas en rutinas de ROM-BIOS

C++ C++ ANSI C

COMPLEX.H CONIO.H CTYPE.H DIR.H

Define las funciones matemticas complejas Define varias funciones utilizadas en las llamadas a rutinas de E/S por consola en DOS Contiene informacin utilizada por las macros de conversin y clasificacin de caracteres Contiene definiciones para trabajar con directorios.

DOS.H

Declara constantes y da las declaraciones necesarias para llamadas especficas del 8086 y del DOS Declara mnemnicos constantes para cdigos de error Declara constantes simblicas utilizadas en conexiones con la biblioteca de rutinas open() Contiene parmetros para rutinas de coma flotante

ANSI C

ERRNO.H FCNTL.H

ANSI.C

FLOAT.H

196

La biblioteca de funcionesLENGUAJE ARCHIVO DE CABECERA FSTREAM.H GENERIC.H GRAPHICS.H IO.H DESCRIPCIN C++ C++ C++ Define los flujos de C++ que soportan E/S de archivos Contiene macros para declaraciones de clase genricas Define prototipos para las funciones grficas Declaraciones de rutinas de E/S tipo UNIX

C++ C++ ANSI C ANSI C ANSI C

IOMANIP.H IOSTREAM.H LIMITS.H LOCALE.H MATH.H MEM.H

Define los gestores de flujos de E/S de C++ y contiene macros para creacin de gestores de parmetros Define rutinas bsicas de flujo de E/S de C++ (v2.0) Parmetros y constantes sobre la capacidad del sistema Define funciones sobre el pas e idioma Define prototipos para las funciones matemticas Define las funciones de gestin de memoria

PROCESS.H

Contiene estructuras y declaraciones para las funciones spawn(), exec()

ANSI C

SETJMP.H SHARE.H

Declaraciones para dar soporte a saltos no locales Parmetros utilizados en funciones que utilizan arhivos-compartidos

ANSI C

SIGNAL.H

Declara constantes y declaraciones para utilizarlos en funciones signal() y raise()

197

La biblioteca de funcionesLENGUAJE ANSI C ANSI C ANSI C C++ ANSI C C++ ANSI C ARCHIVO DE CABECERA STDARG.H STDDEF.H STDIO.H STDIOSTR.H STDLIB.H STREAM.H STRING.H SYS\STAT.H DESCRIPCIN Soporte para aceptar un nmero variable de argumentos Declara varios tipos de datos y macros de uso comn Declara tipos y macros para E/S estndar Declara las clases de flujo para utilizar con estructuras del archivo stdio.h Define algunas de las rutinas comnmente utilizadas Define las clases de flujo de C++ para utilizarlas con arrays de bytes en memoria Define varias rutinas de manipulacin de cadenas y de memoria Declara constantes simblicas utilizadas para abrir y crear archivos

SYS\TIMEB.H

Define la funcin ftime() y la estructura timeb

C++ ANSI C

SYS\TYPES.H TIME.H VALUES.H

Define el tipo time_t Estructuras y prototipos para funciones de tiempo Declara constantes dependientes de la mquina

198

Punteros y arraysTema 14

199

Punteros y arraysObjetivos:Introducir el concepto de puntero. Introducir el concepto de tipo de dato estructurado. Mostrar la representacin de datos mediante arrays unidimensionales y multidimensionales. Conocer la representacin de cadenas de caracteres y las funciones de manipulacin.

Contenidos:1. Punteroso Declaracin o Operadores

2. Arrayso o o o Declaracin Subndices Almacenamiento en memoria Tamao de los arrays

3. Inicializacin de un array 4. Array de caracteres y cadenas de texto 5. Arrays multidimensionales200

PunterosUn puntero es una variable que contiene una direccin de memoria. Por ejemplo, la direccin de otra variable .

201

Punteros (y 2)Las variables puntero se declaran de la siguiente forma: tipo *nombre; siendo nombre el identificador de la variable puntero, y tipo el tipo de variable a la que apunta. Por ejemplo:char *m; int *n; float *p;

En estas declaraciones, las variables m, n y p son punteros que apuntan, respectivamente, a datos de tipo char, int y float.

202

Punteros (y 3)Los operadores de punteros son:& * direccin de en la direccin de

El operador * slo se puede aplicar a punteros Las operaciones permitidas con punteros son:Asignacin Incremento / Decremento Suma / Resta Comparacin

203

Asignacin punterosDadas las declaracionesfloat x; float *p, *q;

la forma de asignar a p y q la direccin de x es:p = &x; q = &x;

Ahora p y q almacenan la misma direccin de memoria: la de la variable x. El mismo efecto se consigue con la asignacin directa entre punteros: p = &x; q = p; No es correcta una sentencia como p = x;

204

Ejemplo#include main() { int x; /* variable entera */ int y; /* variable entera */ int *px; /* variable puntero a entero */ x = 5; px = &x; /* asigna a px la direccion de x */ y = *px; /* asigna a y el contenido de la direccion almacenada en px */ printf("x = %d\n", x); printf("y = %d\n", y); printf("*px = %d\n", *px); }1

int x; int y; int *px; x=5; (&x) 1000 5 px=&x;

3

(&x) 1200

5

y=*px;2

(&px) 3000

100 0

205

EjercicioDado el siguiente fragmento de cdigo:float n1; float n2; float *p1; float *p2; n1 = 4.0; p1 = &n1; p2 = p1; n2 = *p2; n1 = *p1 + *p2; Cunto vale n1 y n2?

206

Incremento / DecrementoLos operadores ++ y -- actan de modo diferente segn el tipo apuntado por el puntero. Si p es un puntero a caracteres (char *p) la operacin p++ incrementa el valor de p en 1. Si embargo, si p es un puntero a enteros (int *p), la misma operacin p++ incrementa el valor de p en 2 para que apunte al siguiente elemento, pues el tipo int ocupa dos bytes. Del mismo modo, para el tipo float la operacin p++ incrementa el valor de p en 4. Lo dicho para el operador ++ se cumple exactamente igual, pero decrementando, para el operador --.207

Suma / RestaOcurre exactamente lo mismo que con las operaciones de incremento y decremento. Si p es un puntero, la operacin p = p + 5; hace que p apunte 5 elementos ms all del actual. Si p estaba definido como un puntero a caracteres, se incrementar su valor en 5, pero si estaba definido como un puntero a enteros, se incrementar en 10.

208

ComparacinPueden compararse punteros del mismo modo que cualquier otra variable, teniendo siempre presente que se comparan direcciones y NO contenidos. int *p, *q; if (p == q) puts ("p y q apuntan a la misma posicin de memoria");

209

Puntero NULLCuando se asigna 0 a un puntero, este no apunta a ningn objeto o funcin. La constante simblica NULL definida en stdio.h tiene el valor 0 y representa el puntero nulo. Es una buena tcnica de programacin asegurarse de que todos los punteros toman el valor NULL cuando no apuntan a ningn objeto o funcin. int *p = NULL; Para ver si un puntero no apunta a ningn objeto o funcin:if (p == NULL) printf("El puntero es nulo\n"); else printf("El contenido de *p es\n", *p);210

ArraysConjunto de datos del mismo tipo a los que se da un nombre comn y a los que se accede a travs de un ndice tipo_dato variable_array[num_elem]; int numeros[20]; float temperaturas[100]; En un vector de N elementos, el primero se referencia con el ndice 0 y el ltimo con el ndice N-1 Inicializacinint numeros[2]={0,1} int numeros[]={0,1} el compilador asume array de 2 elementos

El procesamiento se debe hacer elemento a elemento211

Ejemplo arrays#include #define TAM_VECTOR 10 main() { int vector_a[TAM_VECTOR]; int vector_b[TAM_VECTOR]; int j; /* variable utilizada como indice */ /* leer el vector a */ for (j = 0; j < TAM_VECTOR; j++) { printf("Elemento %d: ", j); scanf("%d", &vector_a[j]); } /* copiar el vector */ for (j = 0; j < TAM_VECTOR; j++) vector_b[j] = vector_a[j]; /* escribir el vector b */ for (j = 0; j < TAM_VECTOR; j++) printf("El elemento %d es %d \n", j, vector_b[j]); }

212

Cadenas de caracteresUn caso particular de vector es la cadena de caracteres. Se declara: char nombre[num_car]; y permite almacenar num_car-1 caracteres y el carcter nulo '\0' de terminacin. char frase[21]; es apta para almacenar 20 caracteres y el nulo. C permite la inicializacin de cadenas de caracteres en la declaracin, mediante sentencias del tipo char cadena[ ] = "Esto es una cadena de caracteres"; en la que no es necesario aadir el nulo final ni indicar el tamao, pues lo hace automticamente el compilador.213

Cadenas de caracteres

Una forma de asignar un valor a una cadena es la siguiente: char cadena[10]; strcpy(cadena, "Hola");

214

biblioteca estndar string.hchar *strcat (char *cad1, const char *cad2) Concatena cad2 a cad1 devolviendo la direccin de cad1. Elimina el nulo de terminacin de cad1 inicial. char *strcpy (char *cad1, const char *cad2) Copia la cadena cad2 en cad1, sobreescribindola. Devuelve la direccin de cad1. El tamao de cad1 debe ser suficiente para albergar a cad2. int strlen (const char *cad) int isalnum (int ch) int isalpha (int ch) int isdigit (int ch) int islower (int ch) int isupper (int ch) int tolower (int ch) int toupper (int ch) Devuelve el nmero de caracteres que almacena cad (sin contar el nulo final). Devuelve 1 si ch es alfanumrico (letra del alfabeto o dgito) y 0 en caso contrario. Devuelve 1 si ch es una letra del alfabeto y 0 en caso contrario. Devuelve 1 si ch es un dgito del 0 al 9, y 0 en caso contrario. Devuelve 1 si ch es un letra minscula y 0 en caso contrario. Devuelve 1 si ch es una letra mayscula y 0 en caso contrario. Devuelve el carcter ch en minscula. Si ch no es una letra mayscula la funcin devuelve ch sin modificacin. Devuelve el carcter ch en mayscula. Si ch no es una letra minscula la funcin devuelve ch sin modificacin.215

Lectura y escritura de cadenas de caracteres#include #define TAM_CADENA 80 main() { char cadena[TAM_CADENA]; printf("Introduzca una cadena: "); scanf("%s", cadena); printf("La cadena es %s\n", cadena); } scanf deja de buscar cuando encuentra un blanco si se introduce Hola a todos, solo se leer Hola. No es necesario el operador de direccin (&) ya que cadena representa de forma automtica la direccin de comienzo.216

Lectura y escritura de cadenas de caracteres (y 2)La funcin gets lee una lnea completa hasta que encuentre el retorno de carro incluyendo los blancos. La funcin puts escribe una cadena de caracteres junto con un salto de lnea.#include #define TAM_LINEA 80 main() { char linea[TAM_LINEA]; printf("Introduzca una linea: \n"); gets(linea); puts("La linea es"); puts(linea); } puts("La linea es:"); es equivalente a: printf("La linea es: \n");

217

EjemploEl programa siguiente hace uso de alguna de las funciones anteriores para examinar una cadena de caracteres y convertir las minsculas a maysculas y viceversa. Adems cuenta cuntos caracteres son dgitos numricos. #include #include #include #include void main (void) { char cadena[100]; int contador = 0; register int i; clrscr (); printf ("\nTeclee una cadena de caracteres: "); gets (cadena); for (i = 0; i y));

}void imprimir_punto(struct punto p) { printf("x = %f\n", p.x); printf("y = %f\n", p.y); }235

Argumentos de la funcin main()Ejecutar un programa con parmetros de entrada (en lnea de comandos) main (int argc, char *argv[ ])argc: Entero que indica el nmero de parmetros tecleados (incluye el nombre del programa). argv[ ]: Matriz de cadenas de caracteres. Cada uno de los elementos argv[i] es una cadena que almacena un argumento.

236

Argumentos de la funcin main()La variable argc vale 1 como mnimo, puesto que se cuenta el nombre del programa. Los parmetros se identifican mediante argv de la siguiente manera: argv[0] argv[1] argv[2] ... ... argv[argc] cadena que almacena el nombre del programa. cadena que almacena el primer parmetro. cadena que almacena el segundo parmetro.

vale cero (En realidad es un puntero nulo).

Para que los argumentos sean tratados como diferentes tienen que ir separados por uno o varios espacios blancos237

EjemploPrograma que lista los parmetros, si los hay, de la lnea de rdenes. #include void main (int argc, char *argv[ ]) { register int i; printf ("\nNombre del programa: %s", argv[0]); if (argc == 1) printf ("\nNo se han introducido parmetros"); else { printf ("\nParmetros en la lnea de rdenes: "); for (i = 1; i < argc; i++) printf ("\n%d: %s", i, argv[i]); } }238