introducción al lenguaje de programación c -...
TRANSCRIPT
Introducción al Lenguaje de Programación C
Un paralelo de C con Pascal
Contenidos
Introducción al Lenguaje de Programación C...................................................1Contenidos ..........................................................................................................0
Autores y Contacto ...............................................................................................0Objetivo .................................................................................................................2
Historial de Revisiones.......................................................................................2Historia y Estándares ...........................................................................................2Usos ........................................................................................................................4Compiladores y Entornos Integrados de Desarrollo .........................................4Tipos.......................................................................................................................5Funciones...............................................................................................................6Variables................................................................................................................7Sentencias ..............................................................................................................7
Comentarios........................................................................................................7Bloques de sentencias.........................................................................................8Asignación ..........................................................................................................8Operador ternario................................................................................................8Operaciones aritméticas......................................................................................9Operación sobre la misma variable ....................................................................9Autoincremento, autodecremento.......................................................................9Llamada a Función ...........................................................................................10Pasaje de parámetros ........................................................................................10
Selectores .............................................................................................................10If-else ................................................................................................................10Case ..................................................................................................................10
Ciclos....................................................................................................................11While ................................................................................................................11Repeat-Until, Do-While....................................................................................11For.....................................................................................................................11
Registros ..............................................................................................................12
Arrays ..................................................................................................................12Matrices ............................................................................................................13
Punteros...............................................................................................................13Strings ..................................................................................................................15
Tipo String de Pascal ........................................................................................15Strings Null-Terminated de C...........................................................................16
Bibliotecas estándar............................................................................................17string.h ..............................................................................................................17stdio.h ...............................................................................................................17math.h ...............................................................................................................20stdlib.h ..............................................................................................................20
Memoria dinámica..............................................................................................20Archivos...............................................................................................................22
Acceso directo ..................................................................................................23Bibliografía recomendada..................................................................................24Fuentes.................................................................................................................24
Autores y Contacto• Ezequiel González Busquin: [email protected]• José Partre: [email protected]
Objetivo
Esta es una guía desarrollada para la introducción al lenguaje C para el curso del Lic. PabloGuarna de la materia 75.40 Algoritmos y Programación I de la Facultad de Ingeniería de laUniversidad de Buenos Aires.La audiencia de este documento son los alumnos del curso, quienes han adquirido recientementeconocimientos sobre programación estructurada en lenguaje Pascal y se inician hacia el manejode la sintaxis y la programación en C.
Historial de Revisiones
Fecha Versión Descripción03/12/20071.0 Versión Inicial 2° Cuatrimestre 200703/06/20101.1 Revisión 1º Cuatrimestre 201007/11/20101.2 Revisión 2º Cuatrimestre 2010
Historia y Estándares
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 características fueron tomadas de un lenguajeanterior llamado "B".
El principal objetivo a lograr era crear un lenguaje de programación que estuviera relativamentea bajo nivel (es decir, que permita manejar los recursos de la computadora casi como se puedehacer usando lenguaje de máquina) para permitir la portabilidad de programas entre distintasplataformas de hardware.Hay muchas leyendas acerca del origen de C y el sistema operativo con el que está íntimamenterelacionado, Unix. Algunas de ellas son:
• El desarrollo de C fue el resultado del deseo de los programadores de jugar con SpaceTravel. Habían estado jugando en el mainframe de su compañía, pero debido a su pocacapacidad de proceso y al tener que soportar 100 usuarios, Thompson y Ritchie notenían suficiente control sobre la nave para evitar colisiones con los asteroides. Por esemotivo decidieron portar el juego a un PDP-7 de la oficina que no se utilizaba; pero esamáquina no tenía sistema operativo, así que decidieron escribir uno. Finalmentedecidieron portar el sistema operativo del PDP-11 que había en su oficina, pero era muycostoso, pues todo el código estaba escrito en lenguaje ensamblador. Entoncesdecidieron usar un lenguaje de alto nivel y portable para que el sistema operativo sepudiera portar fácilmente de un ordenador a otro. Consideraron usar B, pero carecía delas funcionalidades necesarias para aprovechar algunas características avanzadas delPDP-11. Entonces empezaron a crear un nuevo lenguaje, C.
• La justificación para obtener el ordenador original que se usó para desarrollar Unix fuecrear un sistema que automatizase el archivo de patentes. La versión original de Unix sedesarrolló en lenguaje ensamblador. Más tarde, el lenguaje C se desarrolló para poderreescribir el sistema operativo.
En 1973, el lenguaje C se había 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 delos primeros núcleos de sistema operativo implementados en un lenguaje distinto alensamblador. (Algunos casos anteriores son el sistema Multics, escrito en PL/I, y Master ControlProgram para el B5000 de Burroughs, escrito en ALGOL en 1961).Existen diversos estándares del lenguaje, a saber:
• K&R: Es el estándar del libro de Kernighan & Ritchie, diseñadores del lenguaje.• ANSI C, ISO C, C89: En el año 1989 el American National Standards Institute tomando
como base el estándar de K&R oficializó lo que se conoce popularmente como ANSI C,o C89. En 1990 el mismo estándar fue aprobado por la International StandarizationOrganization, con lo cual el ISO C es el mismo estándar que el ANSI C.
• C99: luego de 10 años de uso masivo y del avance de C++, se hizo una revisión delestándar ANSI C y se incorporaron bondades de C++ (en su mayoría elementos desintaxis, no todo aquello relativo al paradigma de orientación a objetos) al estándar C,dando origen al estándar C99. Las mejoras incluyen:
◦ nuevos tipos de datos, como el long long int, boolean◦ arreglos de longitud variable◦ comentarios de una única línea con //
• C1X: es el nombre propuesto para el estándar que reemplazará a C99, aún en desarrollo.Incorporará al lenguaje el manejo de múltiples hilos de ejecución, entre otros.
Los compiladores generalmente utilizan el estandar ANSI C o el C99, pero pueden tambiénañadir ciertos
aspectos específicos. La ventaja de restringirse a los estándares es que un programa puedepotencialmente ser compilado en distintas plataformas y funcionar sin tener que reescribir nisiquiera una línea de código.
Además de los estándares, diversos fabricantes han desarrollado sus compiladores C. En generalestos desarrollos incluyen al estándar ANSI pero agregan funcionalidad extra.
Usos
• El kernel, corazón 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 porción del código del OpenOffice es código C.• La mayoría de los desarrollos de bajo nivel de hoy en día están hechos usando lenguaje
C junto con algunas rutinas en assembler, lo que permite portar funcionalidades de unhardware a otro sin tener que reescribir nuevamente los programas.
Existen compiladores C para casi la totalidad de las plataformas de hardware existentes. Estopermite que prácticamente cualquier hardware pueda correr programas escritos en C, sin requerirque el programador sea un experto en el lenguaje assembler específico 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 delprofesional analizar y decidir qué herramienta dentro de las posibilidades es la mejor pararesolver el problema al que se enfrenta.
Compiladores y Entornos Integrados de Desarrollo
Existen diversos compiladores de C y diversos entornos integrados de desarrollo (IntegratedDevelopment Enviroment, IDE) para distintas plataformas. Aquí nombramos los más populares
• gcc: GNU C Compiler es el compilador C más popular en el ambiente Linux, puesto queestá incluido en todas las distribuciones. Debido al diseño interno del compilador, resultarelativamente fácil portarlo a otras plataformas, con lo cual el compilador también estádisponible para infinidad de arquitecturas.
• Dev-C++: Es el compilador gcc portado para el entorno Windows. Incluye un entornointegrado de desarrollo y debugger.
• Turbo C: El compilador C de Borland, hermano del Turbo Pascal. El IDE de la pantallaazul es idéntico al de Turbo Pascal. En el Museo de Borland se puede descargar laversión 2.01 gratuitamente.
• Microsoft Visual Studio: El entorno integrado de desarrollo de Microsoft cuenta entreotros (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 eldesarrollo rápido de aplicaciones (Rapid Application Development, RAD). Permitetambién compilar aplicaciones C.
• Eclipse CDT: Extensión para desarrollar en C/C++ para el entorno Eclipse (pseudo-estándar para desarrollos en Java).
• Code::Blocks: Entorno de desarrollo en C++ que permite desarrollar integrándose conel compilador gcc. Es código abierto y multiplataforma.
Tipos
Los tipos de datos atómicos de C son los siguientesTipo de dato en C en Pascal
Entero [ signed | unsigned, short | long ] intintegerPunto Flotante float, double realCaracter signed, unsigned, char charCadena de caracteresNo hay tipo nativo para manejo de strings stringSin tipo definido void No existeBooleano No hay tipo nativo booleano, se utilizan integers 0 y 1 booleanEnumerados enum Implícito
El tamaño de las variables depende siempre de la plataforma en la que se esté trabajando y delcompilador con el cual se esté compilando. Para conocer el tamaño que ocupa una variable o untipo de dato puede utilizarse el operador sizeof.Un int siempre ocupa el tamaño de una "palabra" de la plataforma, es decir, el tamaño del datoque el hardware puede leer de la memoria y procesar en una instrucción de assembler. Porejemplo en DOS un int ocupa 16 bits, en Windows 98 ocupa 32 bits mientras que en WindowsVista de 64 bits ocupa 64 bits.Los char siempre ocupan 1 byte y se utilizan para representar caracteres por medio del códigoASCII, 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 Verdadero0 Cualquier valor distinto de 0
Para renombrar un tipo en C se utiliza la directiva typedef.en C en Pascal
typedef float miReal;typefef double miRealLargo;typedef short int miEnteroCorto;
typemiReal: real;miRealLargo: double;miEnteroCorto: shortint;
Constantes
En C pueden también definirse constantes mediante el uso del modificador const. Para esto sepueden crear variables inalterables en tiempo de ejecución de esta manera
en C en Pascal
const float Pi = 3.1416;const
Pi = 3.1416;
Esto provoca crear una variable, asignarle el valor de inicialización y generar errores decompilación al intentar asignarle un nuevo valor. Puesto que esto desperdicia memoria, el uso deconstantes de este tipo en C es raro y se prefiere su declaración mediante directivas alprecompilador.Para declarar una constante con una directiva se debe hacer uso del #define.#define Pi 3.1416Esto provoca que antes de la compilación se reemplacen en el código fuente posterior al #definetodas las apariciones de "Pi" literalmente por "3.1416". Puede pensarse como un "Search andReplace" ("Buscar y Reemplazar") en un documento de texto, lo que no desperdicia memoriaalguna en el ejecutable.El uso de las directivas al precompilador es una herramienta muy potente, pudiendose hacerinclusiones condicionales de distintas porciones de código (#if-#else-#endif), definición demacros y constantes (#define) e inclusión de archivos (#include).
Funciones
La estructura mínima de un programa C es la siguiente:en C en Pascal
int main(){
return 0;}
program Main;begin
Halt( 0 );end.
main es una función. Es en realidad algo más, porque es la función que primero se ejecutará decualquier programa hecho en C, es decir, es el punto de entrada al programa. El valor que retornamain es el valor que devuelve como salida el programa a quien lo invocó (es conocido comoERRORLEVEL), pudiendo ser utilizado desde scripts este valor (Archivos de procesamiento porlotes o Batch ".BAT" de DOS/Windows, bash u otro shell-script de Linux) para evaluarlo yactuar en consecuencia.int indica el tipo de dato a retornar. A diferencia de Pascal, en C sólo existen funciones. Si unodesea implementar un procedimiento, puede aproximarlo con una función que retorne "void",que es el indicador de tipo de dato inexistente.return indica el valor a retornar por la función. A diferencia de Pascal, main no puede serasignado con un valor. El valor que retorna la función main es devuelto al sistema operativodesde donde se invocó al programa.Una función que reciba parámetros tomaría la forma:
en C en Pascal
int suma(int a, int b){
return a + b;}
function suma(a: integer,b: integer): integer
beginsuma := a + b;
end;En caso de no establecerse el tipo de dato de los parámetros de una función, el compilador tomapor defecto el tipo de dato int.
Variables
Existen obviamente también en C las variables y las hay globales y locales de forma análoga aPascal. A diferencia de Pascal en C no hay un bloque var donde se declaran las variables, sinoque las mismas se declaran dentro del bloque de llaves de la función.
El estándar ANSI C requiere que todas las variables locales se declaren previamente a la primersentencia del programa. Estándares posteriores permiten declarar variables en otras partes delcódigo, incluso dentro de ciclos iterativos.
Las variables globales son las que se declaran fuera de todo bloque, incluso del bloque principaldel programa (main).
en Cint unaVariableGlobal; /* Declaración de una variable global */int otraGlobal = 0; /* Declaración e inicialización */
int main(void){
int unaVariableLocal; /* Declaración de una variable local */int otraLocal = 0; /* Declaración e inicialización */
unaVariableLocal = 5; /* Primera sentencia, no más 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,puede ocuparvarias líneas ... */
{ Esto es un comentariopuede ocuparvarias líneas ... }
Existe también la posibilidad de hacer comentarios hasta el final de la línea. Esto fue introducidoen el estándar C99 y no forma parte del estándar ANSI C.// Esto es un comentario de una línea en C99...
Bloques de sentencias
Los bloques de sentencias begin-end pasan a ser ahora un par de llaves { }. El fin de sentencia seindica siempre con un punto y coma. No se utiliza punto y coma después de la llave que cierra, adiferencia del punto y coma después del end de Pascal.
en C en Pascal{
...}
begin...
end;
Asignación
La asignación se realiza con un único signo igual. Para comparar, deben utilizarse dos signosigual consecutivos.
en C en Pascala = 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 algoparecido 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 sele asignará el valor de DESAPROBADO. Es una forma abreviada de escribir:
if ( nota > 4 )estado = APROBADO;
elseestado = DESAPROBADO;
Operaciones aritméticas
en C en Pascal/* Suma */a = b + C;/* Resta */c = b - a;/* Multiplicación */d = a * b;/* División Entera o Real*/b = c / d;/* Resto de la División */e = b % f;
{Suma}a := b + C;{Resta}c := b - a;{Multiplicación}d := a * b;{División Entera; División Real}b := c div d; x := y / z;{Resto de la División}e := b mod f;
En C la operación de división asigna la parte entera si la variable asignada es de tipo entero, oasigna la división exacta (parte entera y parte decimal) si la variable asignada es de puntoflotante.
Operación sobre la misma variable
en C en Pascala += 2; /* Existen también -=, *=, /= entre otros */ a := a + 2;
Autoincremento, autodecremento
en C en Pascala++; a--;++a; --a;
inc( a ); dec( a );inc( a ); dec( a );
incremento decrementopre ++a; --a;pos a++; a--;
El autoincremento y autodecremento se utiliza para incrementar o decrementar en uno el valor dela variable. Es un método abreviado. La diferencia entre uno y otro radica en algunos casosespeciales, como lo es su uso en ciclos y llamadas a función.
Cuando se usa el preincremento o predecremento la variable ve modifica su valor en 1 previo ala ejecución del ciclo o llamada a función; cuando se utilizan el posincremento o elposdecremento se ejecuta primero el bucle del ciclo o se hace la invocación y el valor de lavariable se ve modificado posteriormente.
Llamada a Función
El uso de los paréntesis es obligatorio.
en C en Pascala = MiFuncion();OtraFuncionSinParametro();
a := MiFuncion;OtraFuncionSinParametros;
Pasaje de parámetros
Los parámetros van entre paréntesis, separados por comas.en C en Pascal
UnaSubrutina(a, 5);a = MiFuncion(5);
UnaSubrutina(a, 5);a := MiFunción(5);
Selectores
If-else
El uso de paréntesis es obligatorio.
en C en Pascalif ( a == 10 ){
...}else{
...}
if a = 10 thenbegin
...endelsebegin
...end;
Para unir condiciones existen equivalentes a los operadores and (&&), or (||) y not (!).en C en Pascal
if ( a == 10 && !( b <= 2 ) )|| c != 4 )
if ( a = 10 and not b <= 2 ) orc <> 4 then
Case
La sentencia case-of pasa a ser una sentencia switch-case. Nótese que es necesario colocar unainstrucción break luego de cada sentencia y que el caso por defecto se indica con la palabra clavedefault.
en C en Pascal
switch ( a ){case 1: CasoUno(); break;case 2: CasoDos(); break;case 3:case 4:case 5: CasoTresCuatroYCinco(); break;default: OtroCaso();
}
case a of
1: CasoUno;2: CasoDos;3,4,5: CasoTresCuatroYCinco;else OtroCaso;
end;
Si se omite la pabra break en alguna sentencia case una vez alcanzado el final del casocorrespondiente se continúa por el caso siguiente.
Ciclos
While
El ciclo While es análogo. El uso de paréntesis para la condición es obligatorio.en C en Pascal
while ( i < 10 ){
...}
while i < 10 dobegin
...end;
Repeat-Until, Do-While
Repeat-until se transforma en un ciclo Do-while, con la misma estructura y comportamiento peronegando la condición de corte.
en C en Pascaldo {
...} while ( i < 10 );
repeat...
until not ( i < 10 );
For
El ciclo For cambia un poco su fisonomía.en C en Pascal
for ( i = 1 ; i < 10 ; i++ ){
...}
for i := 1 to 10 dobegin...
end;Podemos ver que como argumentos del ciclo existen 3 sentencias. Una primera sentencia deinicialización se ejecuta antes que nada, una segunda sentencia de condición se evalúa para
ingresar o no al ciclo. Una vez ejecutado el ciclo se ejecuta la tercer sentencia, en este caso deincremento de la variable de control.Traduciendo el mismo ciclo For en un ciclo While, podríamos 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 otraforma que no sea incrementándola o decrementándola en una unidad, sino haciendo otro tipo deoperaciones según lo requiera el algoritmo.
Registros
En C, al igual que en Pascal, pueden agruparse variables en registros. Para definir un tipo deregistro, crear una variable de ese tipo y acceder a los campos se tiene algo así:
en C en Pascaltypedef struct{
tDatoUno CampoUno;tDatoDos CampoDos;
} tRegistro;
...
tRegistro miVarRegistro;
...
miVarRegistro.CampoUno = valor;
tRegistro = record
CampoUno: tDatoUno;CampoDos: tDatoDos;
end;
...
var miVarRegistro: tRegistro;
...
miVarRegistro.CampoUno = valor;Existe en C un tipo de dato compuesto especial llamado union. Este tipo de dato es un registroque ocupa el tamaño suficiente como para albergar en memoria a su campo más grande. Susintaxis es análoga al struct.Por ejemplo, definiendo una unión de un char y un float y suponiendo que el char ocupa 1 byte yel 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 loscampos 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 lavariable y 40 la cantidad de elementos máxima a almacenar o largo del arreglo.Hay que tener especial cuidado al acceder a los arreglos en C, porque no pueden definirse rangoscomo en Pascal. Siempre el primer elemento se encuentra en la posición 0 del arreglo, y elmáximo elemento accesible es el N-1, donde N es el largo del arreglo.El típico ciclo para recorrer un arreglo de principio a fin es
en C en Pascalfor (i=0; i<MAX; i++)
miArreglo[i] = 0;{ otroArreglo = array [1..40] of integer; }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 común y muchas veces no es reportado por elcompilador, pudiendo llevar a cuelgues del programa por acceder a memoria fuera de los límitesdel arreglo.Como se verá más adelante, en realidad C reserva la memoria (40 bytes en este caso) para lavariable y asigna a miArreglo la posición de memoria donde comienzan esos 40 bytes. Enrealidad miArreglo es un puntero a int y es asignado con la dirección de memoria del primer intde la variable, es decir, con la dirección de memoria de miArreglo[0].
Matrices
Para declarar arrays multidimensionales la sintaxis define la cantidad de elementos de ladimensión. Siempre el primer elemento está en la posición cero. Para accederla la sintaxis esanáloga a Pascal.
en C en Pascalint miMatriz3D[40][20][50];
...miMatriz3D[24][0][49] = 255;
var miMatriz3D:array[0..39][0..19][0..49]of integer;
...miMatriz3D[24][0][49] := 255;
Punteros
Como se vio en Pascal, los punteros no son ni más ni menos que variables. El contenido de lasmismas es una posición de memoria, tal como el contenido de un int es un número entero o de unfloat un número real.En C para indicar una variable puntero, se utiliza el caracter asteriscoint *pMiEntero;De esta forma tenemos una variable llamada pMiEntero de tipo "puntero a int". Esta variable estásin inicializar, por lo cual la dirección de memoria que almacena puede ser cualquiera. ¡Cuidado!Existe una constante definida y famosa llamada NULL (equivalente al nil de Pascal) que permiteindicar que un puntero apunta a una posición inválida de la memoria.pMiEntero = NULL;
Con esto salvamos de acceder a memoria sin inicializar, puesto que el programa generalmentefinaliza su ejecución cuando se intenta acceder a la memoria apuntando a NULL.Para obtener la dirección de memoria de una variable existe en C el operador ampersand. De estaforma podríamos hacer/* Declaro 2 variables int y una variable int* */int a, b, *pMiEntero;
/* Inicializo */a = 5;b = 10;
/* Asigno a pMiEntero la dirección de memoria de a */pMiEntero = &a;
/* asigno a b lo que hay en la dirección de memoria apuntadapor pMiEntero, es decir, lo que hay en a, es decir que ahora bvale 5 */b = *pMiEntero;
Haciendo un paralelo con Pascal, podríamos hacer lo siguiente:en C en Pascal
typedef int* pMiEntero;
...
pMiEntero pA;int A;
pA = NULL;
pA = &A;
*pA = 5;
type pMiEntero = ^integer;
...
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 primerelemento.int miArreglo[40];int *p;
p = miArreglo; /* ¡Es válido! p apunta a miArreglo[0]... en realidad son dos variables tipo int* */p = &miArreglo[0]; /* Esto es análogo a la línea anterior */p[0] = 5; /* Puedo indexar p como un array, de estaforma accedo a la primer posición de miArreglo */
p[1] = 20; /* Asigna el valor 20 al segundo elementode miArreglo */p[2] = *miArreglo; /* Asigna el contenido de lo apuntado pormi arreglo (es decir, el contenido de
la primer posición del arreglo) altercer elemento del arreglo */
Strings
Tipo String de Pascal
La implementación de los strings en Pascal es ni más ni menos que un arreglo de bytes. Elprimer byte del arreglo está reservado para almacenar el tamaño lógico del string.Digamos que declaramos un string en Pascal.var cadena : string;El string por defecto toma un máximo de 255 caracteres, pero reservando un caracter extra parael largo, el compilador reservará en memoria 256 bytes para la variable.[0][x][x][x] ... [x] [ ] = 1 byte en memoria RAM0 1 2 3 256 [x] = basura = memoria sin
inicializar^ ^ ^| | || | +-- último caracter del string| || +---------------- primer caracter del string+------------------- longitud lógica
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 longitudlógica actual.[6][P][a][s][c][a][l][x] ... [x]0 1 2 3 4 5 6 256^|+------------------- longitud lógica actualizada
Se observa la limitación de no poder almacenar textos mayores a 255 caracteres en un string y detener desperdiciada una posición de memoria para almacenar la longitud lógica.
Strings Null-Terminated de C
En C los strings se implementan como arreglos de caracteres terminados en nulo. Esto significaque se almacenan caracter tras caracter y se indica el final con el caracter nulo, es decir, uncaracter cuyos bits son todos ceros.No debe confundirse este caracter con el código ASCII para el número cero, que es el ASCII 30hexa = 0x30 = 48 decimal. El caracter nulo es conocido como \0 ("barra cero", debido a la formade 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 decaracteres. Declarando un arreglochar cadena[256];se tendrá que la memoria se reservará para almacenarlo, sin ningún otra acción.[x][x][x][x] ... [x] [ ] = 1 byte en memoria RAM0 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 inicialización.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 válido del string+---------------------------- primer caracter del string
Notar que para delimitar strings deben utilizarse " (comillas dobles) y para caracteres ' (comillassimples).char cadena[256] = "ANSI-C";cadena[4] = '_';De esta forma, con el identificador de la variable se tiene información de dónde comienza (a vermás adelante) el string y recorriéndolo hasta encontrar un caracter nulo se puede saber hastadónde llega.EJERCICIO: Escribir una función en lenguaje C que recibiendouna cadena devuelva su largo.Hay que resaltar que a diferencia de Pascal, C no tiene a los strings como tipo de dato nativo dellenguaje. Esto significa que no pueden hacerse asignaciones o comparaciones de variables detipo string en C.if (cadena == "No se puede comparar así") /* ¡Mal! */
cadena = "No se puede asignar así"; /* ¡Mal! */
Bibliotecas estándar
El lenguaje C define una serie de funciones agrupadas en bibliotecas (libraries) que todocompilador estándar debe brindar. Es el análogo a las units de Pascal.Para hacer uso de una librería, es necesario incluirla en el programa por medio de la directiva#include.
en C en Pascal#include <math.h> uses Math;
string.h
Puesto que C no tiene un manejo estándar de los strings, es de vital importancia las funciones dela biblioteca string.h . Entre las funciones que en ella se encuentra se destacas:
en C en Pascal/*Largo de la cadena s*/strlen( s );
{Largo de la cadena s}length( s );
/*Concatena s2 a s1*/strcat( s1, s2 );
{Concatena s2 a s1}s1 := s1 + s2;
/*Compara alfabéticamente*/cmp = strcmp( s1, s2 )Resulta en cmp==0 si son iguales, cmp<0;si s1<s2 ó cmp>0 si s1>s2
{Compara alfabéticamente}if s1 = s2 then
cmp := 0else if s1 > s2 then
cmp := -1else
cmp := 1;En Pascal la comparación es nativa. Este sería elequivalente a la función strcmp de C.
stdio.h
Esta biblioteca es la que implementa la entrada y salida. Entre otras cosas, define la estructuraFILE para el manejo de archivos y permite obtener datos del teclado, impresiones por pantalla ymanejo de archivos.El formato preciso de salida se logra con la función printf(). Cada llamada a printf contiene unacadena de control de formato que describe el formato de salida. El uso más simple de printf() esimprimir una cadena de texto simple y corriente:
en C en Pascalprintf ("Hola Mundo!");printf ("Hola Mundo!\n");
write ('Hola Mundo!');writeln ('Hola Mundo!');
Para la impresión de variables, no es posible hacerlo directamente como en Pascal, sino quedeben utilizarse marcas dentro del string que indican el formato del dato que quiere mostrarse yluego pasar como argumento los datos en el mismo orden en que aparecen en el string.
El listado de los especificadores y su descripción es el siguiente:Especificador Descripción%c Carácter ASCII correspondiente.%s Cadena de caracteres terminada en el carácter nulo (\0).\n Carácter de fin de línea.\r Carácter retorno del carro.\t Carácter tabulador horizontal.\v Carácter tabulador vertical.\a Timbre.\o Carácter nulo.\\ Barra invertida.\" Comillas dobles.%d%i
Decimal con signo de un entero.
%u Decimal sin signo de un entero.%ld Entero largo con signo.%lu Entero largo sin signo.%f Número real
%m.nf Número real ocupando como mínimo m espacios y redondeado a ndecimales
%e Número real, notación científica%g Coma flotante usando la notación 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";
printf( "La temperatura \hoy es %d°%c, \el promedio fue \de %f \en todo el mes \de %s\n",temp, grado,prom, mes );
temp := 25;grado := "C";prom := 20.5;mes := 'Marzo';
writeln( 'La temperaturahoy es ',temp,'°',grado,
', el promediofue de ', prom,
' en todo elmes de ', mes );
Para obtener datos ingresados por teclado, la contrapartida del read de Pascal, es la funciónhermana de printf: scanf. La misma recibe como parámetros un string con el formato de los datosa leer y luego uno tras otro las direcciones de memoria de las variables donde se almacenarán losdatos.
en C en Pascalint temp;char grado;float prom;char mes[15];
printf( "Ingrese temperatura,\grado, \promedio de
temperaturas \y el mes \separados por \espacios\n");
scanf( "%d %c %f %s",&temp, &grado, &prom, mes);
var temp : integergrado : char;prom : real;mes : string;
writeln( 'Ingrese temperatura,grado, ',
'promedio detemperaturasy el mes ',
'separados porespacios');
readln(temp, grado, prom,mes);
Observar que para la cadena mes no debe tomarse el valor &mes puesto que esa sería ladirección de memoria del puntero a la cadena. La variable mes ya es de por sí un puntero y sucontenido es la dirección de memoria del string.Mem. Cont. Descripción
0x20 [ 'M'] Posición 0 del string, ubicado en la posición dememoria 0x20 y conteniendo el caracter M.0x21 [ 'a'] Posición 1 del string0x22 [ 'r']0x23 [ 'z']0x24 [ 'o']0x25 ['\0'] Caracter delimitador del string válido0x26 [XXXX] Basura, esta posición del string no es válidaactualmente....0x2E [XXXX] Posición 14 del string. Última posición posiblede utilizar, actualmente con basura....0x30 [0x20] Esta es la variable mes. Su contenido es ladirección de memoria del comienzo del string....0x35 [20.5] Esta es la variable prom. Su contenido es larepresentación del número real 20,5.
math.h
Esta es la biblioteca que brinda las operaciones aritméticas más comunes. Ellas son:
Trigonométricasseno coseno tangente
asin(x) Arcosenosin(x) Senosinh(x) Senohiperbólico
acos(x)Arcocosenocos(x) Cosenocosh(x) Cosenohiperbólico
atan(x)Arcotangenteatan2(x,y) Arcotangente dex/ytan(x) Tangentetanh(x) Tangentehiperbólica
Logarítmicas Potenciación Redondeolog(x) Logaritmoneperiano o naturallog10(x) Logaritmobase 10exp(x)Exponencial, retornae^x
pow(x,y)Potencia x^ysqrt(x) Raízcuadrada
ceil(x) El próximonatural N >= xfloor(x) El naturalanterior N <= x
stdlib.h
Esta librería contiene funciones de uso general. Entre ellas las funciones para el manejo dememoria dinámica, conversión de cadenas a números y obtención de números aleatorios.
Conversión de cadenas Números aleatorios Memoria dinámicaatoi(str) Cadena enintatof(str) Cadena enfloatatol(str) Cadena enlong int
srand(sem) Establecersemillarand() Obtienesiguiente aleatorio
mallocObtenciónfreeLiberación
Memoria dinámica
C permite al igual que Pascal un manejo de la memoria dinámica desde el programa. El manejoes análogo a Pascal: se reserva memoria y se asigna la dirección de inicio del bloque a unpuntero. Se accede a la memoria por medio de ese puntero y finalmente se libera la memoriareservada.
en C en Pascalchar *pA, *pB; var pA, pB :
^char;
.../* Reserva 1 byte en memoria y lo apunta conpA */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!, locambiamos
para evitarnos problemas en el futuro */pB = NULL;
...
new (pA);
pA^ := "A";
pB := pA;
pB^ := "B";
dispose (pA);
pB := nil;
La función malloc recibe como parámetro la cantidad de bytes que se desean reservar enmemoria. Para esto hacemos uso del operador sizeof que devuelve el tamaño en bytes de unavariable o tipo de datos. malloc devuelve un puntero tipo void ( un void* ) apuntando alcomienzo del bloque de memoria reservado, o NULL en caso de no haberse podido reservar lacantidad requerida.Es necesario para asignar este bloque de memoria a un puntero tipado hacer un casteo, que esconvertir un tipo de dato explícitamente en otro. Esto se hace encerrando entre paréntesis al tipode dato destino antes del puntero original.En C pueden reservarse no sólo variables atómicas, sino porciones mayores de memoria ydespués ser accedidas como arreglos, según 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 función realloc es análogo a malloc, pero recibe un puntero a un área de memoriapreviamente reservada. Hace que esta porción de memoria se agrande o achique según elparámetro del largo, conteniendo los mismos datos que la memoria original. Si se invoca arealloc con NULL como parámetro puntero, su comportamiento es análogo a malloc.
Archivos
Para hacer uso de archivos en C debe definirse una variable que almacene los datos del archivo amanejar. El tipo de dato FILE es en realidad un puntero a un registro con datos del archivo.
en C en PascalFILE miArchivo = NULL; var miArchivo : file of char;Los archivos en C no son tipados, como en Pascal. No hay diferencia entre los archivos de textoa los binarios, excepto por la forma de accederlos.Para abrir un archivo se utiliza la primitiva fopenmiArchivo = fopen( "archivo.txt", "rt" );El primer parámetro es el path al archivo (dependiente del sistema operativo, obviamente, yrelativo al directorio actual del programa). El segundo parámetro es un string que indica el modode apertura, pudiendo ser una combinación de:r Abre un fichero de texto para lectura w Trunca, a longitud cero o crea un fichero de texto paraescribir a Añade; abre o crea un fichero de texto para escribir al final del fichero (EOF) rb Abreun fichero en modo binario para lectura wb Trunca, a longitud cero o crea un fichero en modobinario para escribir ab Añade; abre o crea un fichero en modo binario para escribir al final delfichero (EOF) r+ Abre un fichero de texto para actualización (lectura y escritura) w+ Trunca, alongitud cero o crea un fichero de texto para actualización a+ Añade; abre o crea un fichero detexto para actualización, escribiendo al final del fichero (EOF) r+b ó rb+ Abre un fichero enmodo binario para actualización (lectura y escritura) w+b ó wb+ Trunca, a longitud cero o crea
un fichero en modo binario para actualización a+b ó ab+ Añade; abre o crea un fichero en modobinario para actualización, escribiendo al final del fichero (EOF)
en C en Pascal
miArchivo = fopen ("archivo.txt","r");
assign( miArchivo,'archivo.txt' );reset( miArchivo );
miArchivo = fopen ("archivo.txt","w+");
assign( miArchivo,'archivo.txt' );rewrite( miArchivo );
miArchivo = fopen ("archivo.txt","a");
assign( miArchivo,'archivo.txt' );append( miArchivo );
Abrir un archivo en modo texto hace que la lectura y escritura de los \r\n de Windows y los \n deLinux sea transparente: una escritura de un \n automáticamente 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 algún otro error.Para leer y escribir de un archivo
en C en Pascalfread ( regBuffer, sizeof(regBuffer), N,miArchivo);
read ( miArchivo,regBuffer );
fwrite ( regBuffer, sizeof(regBuffer),N, miArchivo);
write ( miArchivo,regBuffer );
Lo que hacen las instrucciones fread y fwrite es tomar del archivo de origen hasta N elementosdel tamaño de regBuffer e ir copiándolos uno tras otro en lo apuntado por regBuffer, o viceversa.De esta forma con una única instrucción 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 instrucción feof.
en C en Pascalwhile( !feof( miArchivo ) ){ ...
while not eof( miArchivo )do ...
Para cerrar un archivo que no se utilizará más, se utiliza fclose.en C en Pascal
fclose( miArchivo );miArchivo = NULL; close( miArchivo );
Es conveniente proceder a inutilizar el puntero al archivo para evitar intentos de lectura sobre elarchivo 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 );...fseek( miArchivo, pos, SEEK_SET );
pos := filepos( miArchivo );...seek( miArchivo, pos );
fseek toma como parámetros al archivo y el desplazamiento en bytes, pudiendo ser un valornegativo. El tercer parámetro indica desde dónde contar el desplazamiento, pudiendo ser:Constante Origen del desplazamientoSEEK_SETEl origen del archivoSEEK_CURLa posición actual del punteroSEEK_ENDEl final del archivoNo existe el equivalente de C al filesize, pero puede simularse con una simple rutina:
en C en Pascallong int posActual,largoDelArchivo;...posActual = ftell( miArchivo);fseek( miArchivo, 0, SEEK_END);largoDelArchivo = ftell(miArchivo );fseek( miArchivo, posActual );
var largoDelArchivo: longint;...
largoDelArchivo := filesize(miArchivo );
Bibliografía recomendada
• The C Programming Language - Kernighan & Ritchie. Libro básico de referencia dellenguaje C, escrito por los diseñadores del lenguaje. Fue durante mucho tiempo elestándar de facto del lenguaje.
• Libro de Taller de Programación I de Introducción a C y C++ - Agustín Praino.Escrito por un ex-ayudante de la materia, el libro es una introducción progresiva y conejemplos del lenguaje C y luego da paso a C++. La materia fue durante mucho tiempohasta no hace mucho la primer materia de la carrera donde se veía el lenguaje C, con locual el libro está pensado para programadores de Pascal que se inician en el mundo de C.Altamente recomendado.
• C con clase es una página web donde están documentadas todas las funciones estándarde las librerías de ANSI C en castellano. Muy útil a la hora de programar. Se puedenexplorar las librerías con un listado de las funciones, constantes y macros que definen,así como también listados alfabéticos de las mismas para localizarlas. Comparadiferencias entre los compiladores más populares.
Fuentes
• Lenguaje de Programación C en Wikipedia• C1x en Wikipedia (en inglés)
• Diferencias entre Pascal y C en Wikipedia (en inglés)• Librerías ANSI C en C con clase• De Pascal a C, Gonzalo Soriano, 25/06/2009