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 caracteresNo 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

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 C

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.

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

decremento
--a;
a--;

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;

var pA : pMiEntero;
A : integer;

pA = NULL;

pA := nil;

pA = &A;

pA := @A;

*pA = 5;

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

en Pascal

int temp = 25;

char grado = 'C';
float prom = 20.5;
char mes[15] = "Marzo";

temp := 25;
grado := "C";
prom := 20.5;
mes := 'Marzo';

printf( "La temperatura \

hoy es %d%c, \
el promedio fue \
de %f \
en todo el mes \
de %s\n",
temp, grado,
prom, mes );

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:

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

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

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

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

/* Libera lo apuntado por pA */

free (pA);

dispose (pA);

/* pB apunta a memoria liberada!, lo

cambiamos
para evitarnos problemas en el futuro */
pB = NULL;

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