Introduccin al Lenguaje de Programacin C

Un paralelo de C con Pascal

Contenidos
Introduccin al Lenguaje de Programacin C...................................................1 Contenidos ..........................................................................................................0 Autores y Contacto ...............................................................................................0 Objetivo .................................................................................................................2 Historial de Revisiones.......................................................................................2 Historia y Estndares ...........................................................................................2 Usos ........................................................................................................................4 Compiladores y Entornos Integrados de Desarrollo .........................................4 Tipos.......................................................................................................................5 Funciones...............................................................................................................6 Variables................................................................................................................7 Sentencias ..............................................................................................................7 Comentarios........................................................................................................7 Bloques de sentencias.........................................................................................8 Asignacin ..........................................................................................................8 Operador ternario................................................................................................8 Operaciones aritmticas......................................................................................9 Operacin sobre la misma variable ....................................................................9 Autoincremento, autodecremento.......................................................................9 Llamada a Funcin ...........................................................................................10 Pasaje de parmetros ........................................................................................10 Selectores .............................................................................................................10 If-else ................................................................................................................10 Case ..................................................................................................................10 Ciclos....................................................................................................................11 While ................................................................................................................11 Repeat-Until, Do-While....................................................................................11 For.....................................................................................................................11 Registros ..............................................................................................................12

Arrays ..................................................................................................................12 Matrices ............................................................................................................13 Punteros...............................................................................................................13 Strings ..................................................................................................................15 Tipo String de Pascal........................................................................................15 Strings Null-Terminated de C...........................................................................16 Bibliotecas estndar............................................................................................17 string.h ..............................................................................................................17 stdio.h ...............................................................................................................17 math.h ...............................................................................................................20 stdlib.h ..............................................................................................................20 Memoria dinmica..............................................................................................20 Archivos...............................................................................................................22 Acceso directo ..................................................................................................23 Bibliografa recomendada..................................................................................24 Fuentes.................................................................................................................24

Autores y Contacto
Ezequiel Gonzlez Busquin: egbusquin@gmail.com Jos Partre: me@joephantom.net

Objetivo
Esta es una gua desarrollada para la introduccin al lenguaje C para el curso del Lic. Pablo Guarna de la materia 75.40 Algoritmos y Programacin I de la Facultad de Ingeniera de la Universidad de Buenos Aires. La audiencia de este documento son los alumnos del curso, quienes han adquirido recientemente conocimientos sobre programacin estructurada en lenguaje Pascal y se inician hacia el manejo de la sintaxis y la programacin en C.

Historial de Revisiones
Fecha Versin Descripcin 03/12/20071.0 Versin Inicial 2 Cuatrimestre 2007 03/06/20101.1 Revisin 1 Cuatrimestre 2010 07/11/20101.2 Revisin 2 Cuatrimestre 2010

Historia y Estndares
El desarrollo inicial de C se llev a cabo en los Laboratorios Bell de AT&T entre 1969 y 1973. Se le dio el nombre "C" porque muchas de sus caractersticas fueron tomadas de un lenguaje anterior llamado "B".

El principal objetivo a lograr era crear un lenguaje de programacin que estuviera relativamente a bajo nivel (es decir, que permita manejar los recursos de la computadora casi como se puede hacer usando lenguaje de mquina) para permitir la portabilidad de programas entre distintas plataformas de hardware. Hay muchas leyendas acerca del origen de C y el sistema operativo con el que est ntimamente relacionado, Unix. Algunas de ellas son: El desarrollo de C fue el resultado del deseo de los programadores de jugar con Space Travel. Haban estado jugando en el mainframe de su compaa, pero debido a su poca capacidad de proceso y al tener que soportar 100 usuarios, Thompson y Ritchie no tenan suficiente control sobre la nave para evitar colisiones con los asteroides. Por ese motivo decidieron portar el juego a un PDP-7 de la oficina que no se utilizaba; pero esa mquina no tena sistema operativo, as que decidieron escribir uno. Finalmente decidieron portar el sistema operativo del PDP-11 que haba en su oficina, pero era muy costoso, pues todo el cdigo estaba escrito en lenguaje ensamblador. Entonces decidieron usar un lenguaje de alto nivel y portable para que el sistema operativo se pudiera portar fcilmente de un ordenador a otro. Consideraron usar B, pero careca de las funcionalidades necesarias para aprovechar algunas caractersticas avanzadas del PDP-11. Entonces empezaron a crear un nuevo lenguaje, C. La justificacin para obtener el ordenador original que se us para desarrollar Unix fue crear un sistema que automatizase el archivo de patentes. La versin original de Unix se desarroll en lenguaje ensamblador. Ms tarde, el lenguaje C se desarroll para poder reescribir el sistema operativo. En 1973, el lenguaje C se haba vuelto tan potente que la mayor parte del kernel Unix, originalmente escrito en el lenguaje ensamblador PDP-11/20, fue reescrita en C. ste fue uno de los primeros ncleos de sistema operativo implementados en un lenguaje distinto al ensamblador. (Algunos casos anteriores son el sistema Multics, escrito en PL/I, y Master Control Program para el B5000 de Burroughs, escrito en ALGOL en 1961). Existen diversos estndares del lenguaje, a saber: K&R: Es el estndar del libro de Kernighan & Ritchie, diseadores del lenguaje. ANSI C, ISO C, C89: En el ao 1989 el American National Standards Institute tomando como base el estndar de K&R oficializ lo que se conoce popularmente como ANSI C, o C89. En 1990 el mismo estndar fue aprobado por la International Standarization Organization, con lo cual el ISO C es el mismo estndar que el ANSI C. C99: luego de 10 aos de uso masivo y del avance de C++, se hizo una revisin del estndar ANSI C y se incorporaron bondades de C++ (en su mayora elementos de sintaxis, no todo aquello relativo al paradigma de orientacin a objetos) al estndar C, dando origen al estndar C99. Las mejoras incluyen: nuevos tipos de datos, como el long long int, boolean arreglos de longitud variable comentarios de una nica lnea con // C1X: es el nombre propuesto para el estndar que reemplazar a C99, an en desarrollo. Incorporar al lenguaje el manejo de mltiples hilos de ejecucin, entre otros. Los compiladores generalmente utilizan el estandar ANSI C o el C99, pero pueden tambin aadir ciertos

aspectos especficos. La ventaja de restringirse a los estndares es que un programa puede potencialmente ser compilado en distintas plataformas y funcionar sin tener que reescribir ni siquiera una lnea de cdigo. Adems de los estndares, diversos fabricantes han desarrollado sus compiladores C. En general estos desarrollos incluyen al estndar ANSI pero agregan funcionalidad extra.

Usos
El kernel, corazn del sistema operativo Linux, est escrito totalmente en lenguaje C. La WINAPI, interfaz para el manejo de los recursos del sistema para las aplicaciones de Windows, est escrita en C. La mayor porcin del cdigo del OpenOffice es cdigo C. La mayora de los desarrollos de bajo nivel de hoy en da estn hechos usando lenguaje C junto con algunas rutinas en assembler, lo que permite portar funcionalidades de un hardware a otro sin tener que reescribir nuevamente los programas. Existen compiladores C para casi la totalidad de las plataformas de hardware existentes. Esto permite que prcticamente cualquier hardware pueda correr programas escritos en C, sin requerir que el programador sea un experto en el lenguaje assembler especfico de dicho hardware. Para algunos usos, C est perdiendo terreno frente a otros lenguajes como por ejemplo Python. Hay que tener en cuenta que cada lenguaje es simplemente una herramienta y queda a juicio del profesional analizar y decidir qu herramienta dentro de las posibilidades es la mejor para resolver el problema al que se enfrenta.

Compiladores y Entornos Integrados de Desarrollo

Existen diversos compiladores de C y diversos entornos integrados de desarrollo (Integrated Development Enviroment, IDE) para distintas plataformas. Aqu nombramos los ms populares gcc: GNU C Compiler es el compilador C ms popular en el ambiente Linux, puesto que est incluido en todas las distribuciones. Debido al diseo interno del compilador, resulta relativamente fcil portarlo a otras plataformas, con lo cual el compilador tambin est disponible para infinidad de arquitecturas. Dev-C++: Es el compilador gcc portado para el entorno Windows. Incluye un entorno integrado de desarrollo y debugger. Turbo C: El compilador C de Borland, hermano del Turbo Pascal. El IDE de la pantalla azul es idntico al de Turbo Pascal. En el Museo de Borland se puede descargar la versin 2.01 gratuitamente. Microsoft Visual Studio: El entorno integrado de desarrollo de Microsoft cuenta entre otros (C++, C#, Visual Basic) con la posibilidad de armar programas en lenguaje C. Borland C++ Builder: Hermano del Borland Delphi, el Builder es un entorno para el desarrollo rpido de aplicaciones (Rapid Application Development, RAD). Permite tambin compilar aplicaciones C.

 Eclipse CDT: Extensin para desarrollar en C/C++ para el entorno Eclipse (pseudoestndar para desarrollos en Java). Code::Blocks: Entorno de desarrollo en C++ que permite desarrollar integrndose con el compilador gcc. Es cdigo abierto y multiplataforma.

Tipos
Los tipos de datos atmicos de C son los siguientes Tipo de dato en C en Pascal [ signed | unsigned, short | long ] intinteger Entero float, double real Punto Flotante signed, unsigned, char char Caracter string Cadena de caracteres No hay tipo nativo para manejo de strings void Sin tipo definido No existe boolean Booleano No hay tipo nativo booleano, se utilizan integers 0 y 1 enum Enumerados Implcito El tamao de las variables depende siempre de la plataforma en la que se est trabajando y del compilador con el cual se est compilando. Para conocer el tamao que ocupa una variable o un tipo de dato puede utilizarse el operador sizeof. Un int siempre ocupa el tamao de una "palabra" de la plataforma, es decir, el tamao del dato que el hardware puede leer de la memoria y procesar en una instruccin de assembler. Por ejemplo en DOS un int ocupa 16 bits, en Windows 98 ocupa 32 bits mientras que en Windows Vista de 64 bits ocupa 64 bits. Los char siempre ocupan 1 byte y se utilizan para representar caracteres por medio del cdigo ASCII, al igual que en Pascal. Los booleanos no existen en C. Lo que se suele utilizar son enteros y el criterio a seguir es este: Falso 0 Verdadero Cualquier valor distinto de 0

Para renombrar un tipo en C se utiliza la directiva typedef. en C en Pascal type typedef float miReal; miReal: real; typefef double miRealLargo; miRealLargo: double; typedef short int miEnteroCorto; miEnteroCorto: shortint;

Constantes

En C pueden tambin definirse constantes mediante el uso del modificador const. Para esto se pueden crear variables inalterables en tiempo de ejecucin de esta manera en C const float Pi = 3.1416; en Pascal const Pi = 3.1416;

Esto provoca crear una variable, asignarle el valor de inicializacin y generar errores de compilacin al intentar asignarle un nuevo valor. Puesto que esto desperdicia memoria, el uso de constantes de este tipo en C es raro y se prefiere su declaracin mediante directivas al precompilador. Para declarar una constante con una directiva se debe hacer uso del #define. #define Pi 3.1416 Esto provoca que antes de la compilacin se reemplacen en el cdigo fuente posterior al #define todas las apariciones de "Pi" literalmente por "3.1416". Puede pensarse como un "Search and Replace" ("Buscar y Reemplazar") en un documento de texto, lo que no desperdicia memoria alguna en el ejecutable. El uso de las directivas al precompilador es una herramienta muy potente, pudiendose hacer inclusiones condicionales de distintas porciones de cdigo (#if-#else-#endif), definicin de macros y constantes (#define) e inclusin de archivos (#include).

Funciones
La estructura mnima de un programa C es la siguiente: en C en Pascal int main() program Main; { begin return 0; Halt( 0 ); } end. main es una funcin. Es en realidad algo ms, porque es la funcin que primero se ejecutar de cualquier programa hecho en C, es decir, es el punto de entrada al programa. El valor que retorna main es el valor que devuelve como salida el programa a quien lo invoc (es conocido como ERRORLEVEL), pudiendo ser utilizado desde scripts este valor (Archivos de procesamiento por lotes o Batch ".BAT" de DOS/Windows, bash u otro shell-script de Linux) para evaluarlo y actuar en consecuencia. int indica el tipo de dato a retornar. A diferencia de Pascal, en C slo existen funciones. Si uno desea implementar un procedimiento, puede aproximarlo con una funcin que retorne "void", que es el indicador de tipo de dato inexistente. return indica el valor a retornar por la funcin. A diferencia de Pascal, main no puede ser asignado con un valor. El valor que retorna la funcin main es devuelto al sistema operativo desde donde se invoc al programa. Una funcin que reciba parmetros tomara la forma:

en Pascal function suma(a: integer, int suma(int a, int b) b: integer): integer { begin return a + b; suma := a + b; } end; En caso de no establecerse el tipo de dato de los parmetros de una funcin, el compilador toma por defecto el tipo de dato int.

en C

Variables
Existen obviamente tambin en C las variables y las hay globales y locales de forma anloga a Pascal. A diferencia de Pascal en C no hay un bloque var donde se declaran las variables, sino que las mismas se declaran dentro del bloque de llaves de la funcin. El estndar ANSI C requiere que todas las variables locales se declaren previamente a la primer sentencia del programa. Estndares posteriores permiten declarar variables en otras partes del cdigo, incluso dentro de ciclos iterativos. Las variables globales son las que se declaran fuera de todo bloque, incluso del bloque principal del programa (main). en C
int unaVariableGlobal; /* Declaracin de una variable global */ int otraGlobal = 0; /* Declaracin e inicializacin */ int main(void) { int unaVariableLocal; /* Declaracin de una variable local */ int otraLocal = 0; /* Declaracin e inicializacin */ unaVariableLocal = 5; /* Primera sentencia, no ms variables desde ac */ //... }

Sentencias
Comentarios
Los comentarios en C se encierran entre un par barra-asterisco asterisco-barra. en C en Pascal

/* Esto es un comentario, { Esto es un comentario puede ocupar puede ocupar varias lneas ... */ varias lneas ... } Existe tambin la posibilidad de hacer comentarios hasta el final de la lnea. Esto fue introducido en el estndar C99 y no forma parte del estndar ANSI C. // Esto es un comentario de una lnea en C99...

Bloques de sentencias
Los bloques de sentencias begin-end pasan a ser ahora un par de llaves { }. El fin de sentencia se indica siempre con un punto y coma. No se utiliza punto y coma despus de la llave que cierra, a diferencia del punto y coma despus del end de Pascal. en C en Pascal { begin ... ... } end;

Asignacin
La asignacin se realiza con un nico signo igual. Para comparar, deben utilizarse dos signos igual consecutivos. en C en Pascal a = 5; // entero decimal = 5 a := 5; a = 0xFF; // entero hexadecimal = 255 decimal a := $FF; a = 017; // entero octal = 15 decimal a := &72;

Operador ternario
En C existe un operador ternario que permite hacer asignaciones condicionales. No existe algo parecido en Pascal. La sintaxis es: estado = ( nota > 4 ) ? APROBADO : DESAPROBADO; Es decir, a la variable estado se le asignar el valor de APROBADO si nota es mayor a 4, sino se le asignar el valor de DESAPROBADO. Es una forma abreviada de escribir: if ( nota > 4 ) estado = APROBADO; else estado = DESAPROBADO;

Operaciones aritmticas
en C en Pascal /* Suma */ {Suma} a = b + C; a := b + C; /* Resta */ {Resta} c = b - a; c := b - a; /* Multiplicacin */ {Multiplicacin} d = a * b; d := a * b; /* Divisin Entera o Real*/ {Divisin Entera; Divisin Real} b = c / d; b := c div d; x := y / z; /* Resto de la Divisin */ {Resto de la Divisin} e = b % f; e := b mod f; En C la operacin de divisin asigna la parte entera si la variable asignada es de tipo entero, o asigna la divisin exacta (parte entera y parte decimal) si la variable asignada es de punto flotante.

Operacin sobre la misma variable

en C en Pascal a += 2; /* Existen tambin -=, *=, /= entre otros */ a := a + 2;

Autoincremento, autodecremento
en C a++; a--; ++a; --a; en Pascal inc( a ); dec( a ); inc( a ); dec( a ); incremento pre pos ++a; a++; --a; a--; decremento

El autoincremento y autodecremento se utiliza para incrementar o decrementar en uno el valor de la variable. Es un mtodo abreviado. La diferencia entre uno y otro radica en algunos casos especiales, como lo es su uso en ciclos y llamadas a funcin. Cuando se usa el preincremento o predecremento la variable ve modifica su valor en 1 previo a la ejecucin del ciclo o llamada a funcin; cuando se utilizan el posincremento o el posdecremento se ejecuta primero el bucle del ciclo o se hace la invocacin y el valor de la variable se ve modificado posteriormente.

Llamada a Funcin
El uso de los parntesis es obligatorio. en C a = MiFuncion(); OtraFuncionSinParametro(); en Pascal a := MiFuncion; OtraFuncionSinParametros;

Pasaje de parmetros
Los parmetros van entre parntesis, separados por comas. en C en Pascal UnaSubrutina(a, 5); UnaSubrutina(a, 5); a = MiFuncion(5); a := MiFuncin(5);

Selectores
If-else
El uso de parntesis es obligatorio. en C if ( a == 10 ) { ... } else { ... } en Pascal if a = 10 then begin ... end else begin ... end;

Para unir condiciones existen equivalentes a los operadores and (&&), or (||) y not (!). en C en Pascal if ( a == 10 && !( b <= 2 ) ) if ( a = 10 and not b <= 2 ) or || c != 4 ) c <> 4 then

Case
La sentencia case-of pasa a ser una sentencia switch-case. Ntese que es necesario colocar una instruccin break luego de cada sentencia y que el caso por defecto se indica con la palabra clave default. en C en Pascal

switch ( a ) case a of { case 1: CasoUno(); break; 1: CasoUno; case 2: CasoDos(); break; 2: CasoDos; case 3: 3, case 4: 4, case 5: CasoTresCuatroYCinco(); break; 5: CasoTresCuatroYCinco; default: OtroCaso(); else OtroCaso; } end; Si se omite la pabra break en alguna sentencia case una vez alcanzado el final del caso correspondiente se contina por el caso siguiente.

Ciclos
While
El ciclo While es anlogo. El uso de parntesis para la condicin es obligatorio. en C en Pascal while ( i < 10 ) while i < 10 do { begin ... ... } end;

Repeat-Until, Do-While
Repeat-until se transforma en un ciclo Do-while, con la misma estructura y comportamiento pero negando la condicin de corte. en C en Pascal do { repeat ... ... } while ( i < 10 ); until not ( i < 10 );

For
El ciclo For cambia un poco su fisonoma. en C en Pascal for ( i = 1 ; i < 10 ; i++ ) for i := 1 to 10 do { begin ... ... } end; Podemos ver que como argumentos del ciclo existen 3 sentencias. Una primera sentencia de inicializacin se ejecuta antes que nada, una segunda sentencia de condicin se evala para

ingresar o no al ciclo. Una vez ejecutado el ciclo se ejecuta la tercer sentencia, en este caso de incremento de la variable de control. Traduciendo el mismo ciclo For en un ciclo While, podramos descomponerlo de esta manera: i = 1; while ( i < 10 ) { ... i++; } Como ventaja frente a Pascal, la variable de control en cada ciclo puede ser modificada de otra forma que no sea incrementndola o decrementndola en una unidad, sino haciendo otro tipo de operaciones segn lo requiera el algoritmo.

Registros
En C, al igual que en Pascal, pueden agruparse variables en registros. Para definir un tipo de registro, crear una variable de ese tipo y acceder a los campos se tiene algo as: en C en Pascal typedef struct tRegistro = record { tDatoUno CampoUno; CampoUno: tDatoUno; tDatoDos CampoDos; CampoDos: tDatoDos; } tRegistro; end; ... tRegistro miVarRegistro; ... ... var miVarRegistro: tRegistro; ...

miVarRegistro.CampoUno = valor; miVarRegistro.CampoUno = valor; Existe en C un tipo de dato compuesto especial llamado union. Este tipo de dato es un registro que ocupa el tamao suficiente como para albergar en memoria a su campo ms grande. Su sintaxis es anloga al struct. Por ejemplo, definiendo una unin de un char y un float y suponiendo que el char ocupa 1 byte y el float 4, el union va a ocupar 4 bytes en memoria. Hay que tener especial cuidado de saber qu campo se accede porque la memoria que ocupan los campos es compartida por ellos.

Arrays
Los arreglos en C se definen de la siguiente forma: en C en Pascal

int miArreglo[40]; miArreglo = array [0..39] of integer; donde int significa el tipo de dato de los elementos del arreglo, miArreglo el nombre de la variable y 40 la cantidad de elementos mxima a almacenar o largo del arreglo. Hay que tener especial cuidado al acceder a los arreglos en C, porque no pueden definirse rangos como en Pascal. Siempre el primer elemento se encuentra en la posicin 0 del arreglo, y el mximo elemento accesible es el N-1, donde N es el largo del arreglo. El tpico ciclo para recorrer un arreglo de principio a fin es en C en Pascal for (i=0; i<MAX; i++) { otroArreglo = array [1..40] of integer; } miArreglo[i] = 0; for i := 1 to MAX do otroArreglo[i] := 0; En nuestro ejemplo, miArreglo[0] contiene el primer elemento del arreglo y miArreglo[39] el ltimo. Acceder a miArreglo[40] es un error muy comn y muchas veces no es reportado por el compilador, pudiendo llevar a cuelgues del programa por acceder a memoria fuera de los lmites del arreglo. Como se ver ms adelante, en realidad C reserva la memoria (40 bytes en este caso) para la variable y asigna a miArreglo la posicin de memoria donde comienzan esos 40 bytes. En realidad miArreglo es un puntero a int y es asignado con la direccin de memoria del primer int de la variable, es decir, con la direccin de memoria de miArreglo[0].

Matrices
Para declarar arrays multidimensionales la sintaxis define la cantidad de elementos de la dimensin. Siempre el primer elemento est en la posicin cero. Para accederla la sintaxis es anloga a Pascal. en C en Pascal int miMatriz3D[40][20][50]; var miMatriz3D: array[0..39][0..19][0..49] ... of integer; miMatriz3D[24][0][49] = 255; ... miMatriz3D[24][0][49] := 255;

Punteros
Como se vio en Pascal, los punteros no son ni ms ni menos que variables. El contenido de las mismas es una posicin de memoria, tal como el contenido de un int es un nmero entero o de un float un nmero real. En C para indicar una variable puntero, se utiliza el caracter asterisco int *pMiEntero; De esta forma tenemos una variable llamada pMiEntero de tipo "puntero a int". Esta variable est sin inicializar, por lo cual la direccin de memoria que almacena puede ser cualquiera. Cuidado! Existe una constante definida y famosa llamada NULL (equivalente al nil de Pascal) que permite indicar que un puntero apunta a una posicin invlida de la memoria. pMiEntero = NULL;

Con esto salvamos de acceder a memoria sin inicializar, puesto que el programa generalmente finaliza su ejecucin cuando se intenta acceder a la memoria apuntando a NULL. Para obtener la direccin de memoria de una variable existe en C el operador ampersand. De esta forma podramos hacer /* Declaro 2 variables int y una variable int* */ int a, b, *pMiEntero; /* Inicializo */ a = 5; b = 10; /* Asigno a pMiEntero la direccin de memoria de a */ pMiEntero = &a; /* asigno a b lo que hay en la direccin de memoria apuntada por pMiEntero, es decir, lo que hay en a, es decir que ahora b vale 5 */ b = *pMiEntero; Haciendo un paralelo con Pascal, podramos hacer lo siguiente: en C en Pascal typedef int* pMiEntero; type pMiEntero = ^integer; ... pMiEntero pA; int A; pA = NULL; pA = &A; *pA = 5; ... var pA : pMiEntero; A : integer; pA := nil; pA := @A; pA^ := 5;

Retomando lo dicho sobre arreglos, en realidad un arreglo en C es un puntero al primer elemento. int miArreglo[40]; int *p; p = miArreglo; /* Es vlido! p apunta a miArreglo[0] ... en realidad son dos variables tipo int* */ p = &miArreglo[0]; /* Esto es anlogo a la lnea anterior */ p[0] = 5; /* Puedo indexar p como un array, de esta forma accedo a la primer posicin de miArreglo */

p[1] = 20; /* Asigna el de miArreglo */ p[2] = *miArreglo; /* Asigna el mi arreglo (es decir, el contenido la primer tercer elemento del arreglo */

valor 20 al segundo elemento contenido de lo apuntado por de posicin del arreglo) al

Strings
Tipo String de Pascal
La implementacin de los strings en Pascal es ni ms ni menos que un arreglo de bytes. El primer byte del arreglo est reservado para almacenar el tamao lgico del string. Digamos que declaramos un string en Pascal. var cadena : string; El string por defecto toma un mximo de 255 caracteres, pero reservando un caracter extra para el largo, el compilador reservar en memoria 256 bytes para la variable. [0][x][x][x] ... [x] [ ] = 1 byte en memoria RAM 0 1 2 3 256 [x] = basura = memoria sin inicializar ^ ^ ^ | | | | | +-- ltimo caracter del string | | | +---------------- primer caracter del string +------------------- longitud lgica Luego al asignarle un valor a la cadena ... cadena := 'Pascal'; en la memoria se copian caracter a caracter (byte a byte) estos datos y se actualiza la longitud lgica actual. [6][P][a][s][c][a][l][x] ... [x] 0 1 2 3 4 5 6 256 ^ | +------------------- longitud lgica actualizada Se observa la limitacin de no poder almacenar textos mayores a 255 caracteres en un string y de tener desperdiciada una posicin de memoria para almacenar la longitud lgica.

Strings Null-Terminated de C
En C los strings se implementan como arreglos de caracteres terminados en nulo. Esto significa que se almacenan caracter tras caracter y se indica el final con el caracter nulo, es decir, un caracter cuyos bits son todos ceros. No debe confundirse este caracter con el cdigo ASCII para el nmero cero, que es el ASCII 30 hexa = 0x30 = 48 decimal. El caracter nulo es conocido como \0 ("barra cero", debido a la forma de incluirlo dentro de un string en lenguaje C) o representado en hexadecimal como 0x00. A diferencia de Pascal, los strings en C no son un tipo de dato nativo, sino que son un arreglo de caracteres. Declarando un arreglo char cadena[256]; se tendr que la memoria se reservar para almacenarlo, sin ningn otra accin. [x][x][x][x] ... [x] [ ] = 1 byte en memoria RAM 0 1 2 3 255 [x] = basura = memoria sin inicializar ^ ^ | | | +-- ltimo caracter del string +------------------- primer caracter del string Es posible declarar la variable con un valor de inicializacin. char cadena{256] = "ANSI-C"; con lo cual la memoria se ver de esta forma: [A][N][S][I][-][C][\0] ... [x] 0 1 2 3 4 5 6 255 ^ ^ ^ ^ | | | | | | | +- ltimo caracter del string | | | | | +---------- caracter delimitador | +------------- ltimo caracter vlido del string +---------------------------- primer caracter del string Notar que para delimitar strings deben utilizarse " (comillas dobles) y para caracteres ' (comillas simples). char cadena[256] = "ANSI-C"; cadena[4] = '_'; De esta forma, con el identificador de la variable se tiene informacin de dnde comienza (a ver ms adelante) el string y recorrindolo hasta encontrar un caracter nulo se puede saber hasta dnde llega. EJERCICIO: Escribir una funcin en lenguaje C que recibiendo una cadena devuelva su largo. Hay que resaltar que a diferencia de Pascal, C no tiene a los strings como tipo de dato nativo del lenguaje. Esto significa que no pueden hacerse asignaciones o comparaciones de variables de tipo string en C. if (cadena == "No se puede comparar as") /* Mal! */

cadena = "No se puede asignar as";

/* Mal! */

Bibliotecas estndar
El lenguaje C define una serie de funciones agrupadas en bibliotecas (libraries) que todo compilador estndar debe brindar. Es el anlogo a las units de Pascal. Para hacer uso de una librera, es necesario incluirla en el programa por medio de la directiva #include. en C #include <math.h> en Pascal uses Math;

string.h
Puesto que C no tiene un manejo estndar de los strings, es de vital importancia las funciones de la biblioteca string.h . Entre las funciones que en ella se encuentra se destacas: en C en Pascal /*Largo de la cadena s*/ {Largo de la cadena s} strlen( s ); length( s ); /*Concatena s2 a s1*/ {Concatena s2 a s1} strcat( s1, s2 ); s1 := s1 + s2; {Compara alfabticamente} if s1 = s2 then cmp := 0 /*Compara alfabticamente*/ else if s1 > s2 then cmp = strcmp( s1, s2 ) cmp := -1 Resulta en cmp==0 si son iguales, cmp<0; else si s1<s2 cmp>0 si s1>s2 cmp := 1; En Pascal la comparacin es nativa. Este sera el equivalente a la funcin strcmp de C.

stdio.h
Esta biblioteca es la que implementa la entrada y salida. Entre otras cosas, define la estructura FILE para el manejo de archivos y permite obtener datos del teclado, impresiones por pantalla y manejo de archivos. El formato preciso de salida se logra con la funcin printf(). Cada llamada a printf contiene una cadena de control de formato que describe el formato de salida. El uso ms simple de printf() es imprimir una cadena de texto simple y corriente: en C en Pascal printf ("Hola Mundo!"); write ('Hola Mundo!'); printf ("Hola Mundo!\n"); writeln ('Hola Mundo!');

Para la impresin de variables, no es posible hacerlo directamente como en Pascal, sino que deben utilizarse marcas dentro del string que indican el formato del dato que quiere mostrarse y luego pasar como argumento los datos en el mismo orden en que aparecen en el string. El listado de los especificadores y su descripcin es el siguiente: Especificador Descripcin %c Carcter ASCII correspondiente. %s Cadena de caracteres terminada en el carcter nulo (\0). \n Carcter de fin de lnea. \r Carcter retorno del carro. \t Carcter tabulador horizontal. \v Carcter tabulador vertical. \a Timbre. \o Carcter nulo. \\ Barra invertida. \" Comillas dobles. %d Decimal con signo de un entero. %i %u Decimal sin signo de un entero. %ld Entero largo con signo. %lu Entero largo sin signo. %f Nmero real Nmero real ocupando como mnimo m espacios y redondeado a n %m.nf decimales %e Nmero real, notacin cientfica %g Coma flotante usando la notacin que requiera menor espacio. %x Hexadecimal sin signo. Ejemplo: en C int temp = 25; char grado = 'C'; float prom = 20.5; char mes[15] = "Marzo"; printf( "La temperatura \ hoy es %d%c, \ el promedio fue \ de %f \ en todo el mes \ de %s\n", temp, grado, prom, mes ); en Pascal temp := 25; grado := "C"; prom := 20.5; mes := 'Marzo'; writeln( 'La temperatura hoy es ', temp,'',grado, ', el promedio fue de ', prom, ' en todo el mes de ', mes );

Para obtener datos ingresados por teclado, la contrapartida del read de Pascal, es la funcin hermana de printf: scanf. La misma recibe como parmetros un string con el formato de los datos a leer y luego uno tras otro las direcciones de memoria de las variables donde se almacenarn los datos. en C en Pascal int temp; var temp : integer char grado; grado : char; float prom; prom : real; char mes[15]; mes : string; printf( "Ingrese temperatura,\ grado, \ promedio de temperaturas \ y el mes \ separados por \ espacios\n"); writeln( 'Ingrese temperatura, grado, ', 'promedio de temperaturas y el mes ', 'separados por espacios');

scanf( "%d %c %f %s", readln(temp, grado, prom, &temp, &grado, &prom, mes); mes); Observar que para la cadena mes no debe tomarse el valor &mes puesto que esa sera la direccin de memoria del puntero a la cadena. La variable mes ya es de por s un puntero y su contenido es la direccin de memoria del string. Mem. Cont. Descripcin 0x20 [ 'M'] Posicin 0 del string, ubicado en la posicin de memoria 0x20 y conteniendo el caracter M. 0x21 [ 'a'] Posicin 1 del string 0x22 [ 'r'] 0x23 [ 'z'] 0x24 [ 'o'] 0x25 ['\0'] Caracter delimitador del string vlido 0x26 [XXXX] Basura, esta posicin del string no es vlida actualmente. ... 0x2E [XXXX] Posicin 14 del string. ltima posicin posible de utilizar, actualmente con basura. ... 0x30 [0x20] Esta es la variable mes. Su contenido es la direccin de memoria del comienzo del string. ... 0x35 [20.5] Esta es la variable prom. Su contenido es la representacin del nmero real 20,5.

math.h
Esta es la biblioteca que brinda las operaciones aritmticas ms comunes. Ellas son: Trigonomtricas coseno tangente atan(x) acos(x) Arcotangente Arcocoseno atan2(x,y) Arcotangente de cos(x) Coseno x/y cosh(x) Coseno tan(x) Tangente hiperblico tanh(x) Tangente hiperblica Potenciacin Redondeo pow(x,y) Potencia x^y sqrt(x) Raz cuadrada ceil(x) El prximo natural N >= x floor(x) El natural anterior N <= x

seno asin(x) Arcoseno sin(x) Seno sinh(x) Seno hiperblico Logartmicas log(x) Logaritmo neperiano o natural log10(x) Logaritmo base 10 exp(x) Exponencial, retorna e^x

stdlib.h
Esta librera contiene funciones de uso general. Entre ellas las funciones para el manejo de memoria dinmica, conversin de cadenas a nmeros y obtencin de nmeros aleatorios. Conversin de cadenas Nmeros aleatorios Memoria dinmica atoi(str) Cadena en int srand(sem) Establecer malloc atof(str) Cadena en semilla Obtencin float rand() Obtiene free atol(str) Cadena en siguiente aleatorio Liberacin long int

Memoria dinmica
C permite al igual que Pascal un manejo de la memoria dinmica desde el programa. El manejo es anlogo a Pascal: se reserva memoria y se asigna la direccin de inicio del bloque a un puntero. Se accede a la memoria por medio de ese puntero y finalmente se libera la memoria reservada. en C en Pascal char *pA, *pB; var pA, pB : ^char;

... /* Reserva 1 byte en memoria y lo apunta con pA */ pA = (char*) malloc (sizeof(char)); /* En lo apuntado por pA pone un caracter 'A' */ *pA = 'A'; /* Apunta pB al mismo lugar donde apunta pA */ pB = pA; /* En lo apuntado por pB pone un caracter 'B' */ *pB = 'B'; /* Libera lo apuntado por pA */ free (pA); /* pB apunta a memoria liberada!, lo cambiamos para evitarnos problemas en el futuro */ pB = NULL;

... new (pA); pA^ := "A"; pB := pA; pB^ := "B"; dispose (pA);

pB := nil;

La funcin malloc recibe como parmetro la cantidad de bytes que se desean reservar en memoria. Para esto hacemos uso del operador sizeof que devuelve el tamao en bytes de una variable o tipo de datos. malloc devuelve un puntero tipo void ( un void* ) apuntando al comienzo del bloque de memoria reservado, o NULL en caso de no haberse podido reservar la cantidad requerida. Es necesario para asignar este bloque de memoria a un puntero tipado hacer un casteo, que es convertir un tipo de dato explcitamente en otro. Esto se hace encerrando entre parntesis al tipo de dato destino antes del puntero original. En C pueden reservarse no slo variables atmicas, sino porciones mayores de memoria y despus ser accedidas como arreglos, segn se ha visto antes. char *stringDinamico; int largoActual = 0; int deltaIncremento = 100; char bufferLectura[50]; stringDinamico = (char*) malloc( deltaIncremento * sizeof( char )); stringDinamico[0] = '\0'; largoActual = deltaIncremento;

do { printf( "\nIngrese un texto: \n" ); scanf( "%s", bufferLectura ); if ( strlen( bufferLectura ) + strlen( stringDinamico ) > largoActual ) { stringDinamico = (char*) realloc ( stringDinamico, (largoActual + deltaIncremento) * sizeof( char )); largoActual += deltaIncremento; } strcat( stringDinamico, bufferLectura ); } while ( strlen( bufferLectura ) > 0 ); printf( "Todo lo ingresado fue %s", stringDinamico ); La funcin realloc es anlogo a malloc, pero recibe un puntero a un rea de memoria previamente reservada. Hace que esta porcin de memoria se agrande o achique segn el parmetro del largo, conteniendo los mismos datos que la memoria original. Si se invoca a realloc con NULL como parmetro puntero, su comportamiento es anlogo a malloc.

Archivos
Para hacer uso de archivos en C debe definirse una variable que almacene los datos del archivo a manejar. El tipo de dato FILE es en realidad un puntero a un registro con datos del archivo. en C en Pascal FILE miArchivo = NULL; var miArchivo : file of char; Los archivos en C no son tipados, como en Pascal. No hay diferencia entre los archivos de texto a los binarios, excepto por la forma de accederlos. Para abrir un archivo se utiliza la primitiva fopen miArchivo = fopen( "archivo.txt", "rt" ); El primer parmetro es el path al archivo (dependiente del sistema operativo, obviamente, y relativo al directorio actual del programa). El segundo parmetro es un string que indica el modo de apertura, pudiendo ser una combinacin de: r Abre un fichero de texto para lectura w Trunca, a longitud cero o crea un fichero de texto para escribir a Aade; abre o crea un fichero de texto para escribir al final del fichero (EOF) rb Abre un fichero en modo binario para lectura wb Trunca, a longitud cero o crea un fichero en modo binario para escribir ab Aade; abre o crea un fichero en modo binario para escribir al final del fichero (EOF) r+ Abre un fichero de texto para actualizacin (lectura y escritura) w+ Trunca, a longitud cero o crea un fichero de texto para actualizacin a+ Aade; abre o crea un fichero de texto para actualizacin, escribiendo al final del fichero (EOF) r+b rb+ Abre un fichero en modo binario para actualizacin (lectura y escritura) w+b wb+ Trunca, a longitud cero o crea

un fichero en modo binario para actualizacin a+b ab+ Aade; abre o crea un fichero en modo binario para actualizacin, escribiendo al final del fichero (EOF) en C en Pascal assign( miArchivo, miArchivo = fopen ("archivo.txt", 'archivo.txt' ); "r"); reset( miArchivo ); assign( miArchivo, miArchivo = fopen ("archivo.txt", 'archivo.txt' ); "w+"); rewrite( miArchivo ); assign( miArchivo, miArchivo = fopen ("archivo.txt", 'archivo.txt' ); "a"); append( miArchivo ); Abrir un archivo en modo texto hace que la lectura y escritura de los \r\n de Windows y los \n de Linux sea transparente: una escritura de un \n automticamente se traduce a un \r\n en Windows, y una lectura de un \r\n se almacena en memoria como un \n. fopen devuelve NULL en caso de no poder abrir el archivo indicado, ya sea porque no existe, porque no se cuenta con los permisos necesarios o algn otro error. Para leer y escribir de un archivo en C en Pascal fread ( regBuffer, sizeof(regBuffer), N, read ( miArchivo, miArchivo); regBuffer ); fwrite ( regBuffer, sizeof(regBuffer), write ( miArchivo, N, miArchivo); regBuffer ); Lo que hacen las instrucciones fread y fwrite es tomar del archivo de origen hasta N elementos del tamao de regBuffer e ir copindolos uno tras otro en lo apuntado por regBuffer, o viceversa. De esta forma con una nica instruccin pueden copiarse strings y arreglos enteros en memoria, o porciones de los mismos. fread y fwrite devuelven la cantidad de elementos copiados. Para verificar si el cursor del archivo se encuentra al final, se utiliza la instruccin feof. en C en Pascal while( !feof( miArchivo ) ) while not eof( miArchivo ) { ... do ... Para cerrar un archivo que no se utilizar ms, se utiliza fclose. en C en Pascal fclose( miArchivo ); close( miArchivo ); miArchivo = NULL; Es conveniente proceder a inutilizar el puntero al archivo para evitar intentos de lectura sobre el archivo cerrado.

Acceso directo
Es posible el manejo de archivos con acceso directo como en Pascal. en C en Pascal long int pos; var pos: longint; ... ...

pos = ftell( miArchivo ); pos := filepos( miArchivo ); ... ... fseek( miArchivo, pos, SEEK_SET ); seek( miArchivo, pos ); fseek toma como parmetros al archivo y el desplazamiento en bytes, pudiendo ser un valor negativo. El tercer parmetro indica desde dnde contar el desplazamiento, pudiendo ser: Constante Origen del desplazamiento SEEK_SETEl origen del archivo SEEK_CURLa posicin actual del puntero SEEK_ENDEl final del archivo No existe el equivalente de C al filesize, pero puede simularse con una simple rutina: en C en Pascal long int posActual, largoDelArchivo; var largoDelArchivo: longint; ... ... posActual = ftell( miArchivo ); fseek( miArchivo, 0, SEEK_END largoDelArchivo := filesize( ); miArchivo ); largoDelArchivo = ftell( miArchivo ); fseek( miArchivo, posActual );

Bibliografa recomendada
The C Programming Language - Kernighan & Ritchie. Libro bsico de referencia del lenguaje C, escrito por los diseadores del lenguaje. Fue durante mucho tiempo el estndar de facto del lenguaje. Libro de Taller de Programacin I de Introduccin a C y C++ - Agustn Praino. Escrito por un ex-ayudante de la materia, el libro es una introduccin progresiva y con ejemplos del lenguaje C y luego da paso a C++. La materia fue durante mucho tiempo hasta no hace mucho la primer materia de la carrera donde se vea el lenguaje C, con lo cual el libro est pensado para programadores de Pascal que se inician en el mundo de C. Altamente recomendado. C con clase es una pgina web donde estn documentadas todas las funciones estndar de las libreras de ANSI C en castellano. Muy til a la hora de programar. Se pueden explorar las libreras con un listado de las funciones, constantes y macros que definen, as como tambin listados alfabticos de las mismas para localizarlas. Compara diferencias entre los compiladores ms populares.

Fuentes
Lenguaje de Programacin C en Wikipedia C1x en Wikipedia (en ingls)

 Diferencias entre Pascal y C en Wikipedia (en ingls) Libreras ANSI C en C con clase De Pascal a C, Gonzalo Soriano, 25/06/2009