Repasamos algunos conceptos a través de ejemplos comparados, primeramente en C.

/**********************************************/
/* OPERADOR.C */
/**********************************************/
/* Declaraciones globales */
int i=0,j=0,menor,mayor; /* inicializacion de variables i y j */

int main(void)
{ /* Declaraciones locales (para la funcion main) */
char c=5,d=0; /* Inicializacion de las variables c y d */
const unsigned int k=3; /* Declaracion de la constante k */

i=i+1; /* .................... i=1 suma 1 a i */

i++; /* ...................... i=2 incrementa i */
++i; /* ...................... i=3 incrementa i */
j=i++; /* .................... i=4,j=3 asigna i a j e incrementa i
*/
j=++i; /* .................... i=5,j=5 incrementa i y asigna a j */

c=c-1; /* .................... c=4 resta 1 a i */

c--; /* ...................... c=3 decrementa i */
--c; /* ...................... c=2 decrementa i */
d=c--; /* .................... c=1,d=2 asigna c a d y decr. c */
d=--c; /* .................... c=0,d=0 decrementa c y asigna a d */

i=i%3;/*...................... i=2 Obtiene modulo (resto division)*/

j+=k; /* ..................... j=8 Suma k a j */
j-=k; /* ..................... j=5 Resta k a j */
j*=k; /* ..................... j=15 Almacena en j el producto j*k */
j/=k; /* ..................... j=5 Almacena en j el cociente j/k */

d=(c=5,c+3); /* .............. c=5, d=8 Calcula expresiones

encadenadas y asigna el resultado */
d=(c=3,i=4,j=5,c*=i,c*j); /* c=12, i=4, j=5, d=60 */

d=i>j?c:i; /* ................ d=4 Asignacion condicional:

si i>j entonces
d=c
sino
d=i */
d=i<j?1:0; /* ................ d=1 */

menor=i<j?i:j; /* ............ menor=4 */

mayor=i>j?i:j; /* ............ mayor=5 */

d=d+mayor*menor; /* .......... d=21 */

return 0;
}

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 57
Y la misma lógica en lenguaje Pascal, mostrando resultados en pantalla.

uses crt;
var
i:integer=0;
j:integer=0;
menor,mayor:integer;
c:shortint=5;
d:shortint=0;
const
k:word=3;
begin
clrscr;
i:=i+1; writeln(i,' ',j);
i:=i+1; writeln(i,' ',j);
i:=i+1; writeln(i,' ',j);
j:=i;i:=i+1; writeln(i,' ',j);
i:=i+1;j:=i; writeln(i,' ',j);

c:=c-1; writeln(c,' ',d);

c:=c-1; writeln(c,' ',d);
c:=c-1; writeln(c,' ',d);
d:=c;c:=c-1; writeln(c,' ',d);
c:=c-1;d:=c; writeln(c,' ',d);

i:=i mod 3; writeln(i);

j:=j+k; writeln(j);
j:=j-k; writeln(j);
j:=j*k; writeln(j);
j:=j div k; writeln(j);

c:=5;d:=c+3; writeln(c,' ',d);

c:=3;i:=4;j:=5;c:=c*i;d:=c*j; writeln(c,' ',i,' ',j,' ',d);

if i>j then
d:=c
else
d:=i; writeln(d);
readkey;
end.

Se obviaron las últimas líneas de sentencia, debido a que son semejantes a las anteriores.

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 58
Conversión de tipos en lenguaje C
Cuando se realiza una operación entre dos operandos de distinto tipo, el resultado de esta será
del tipo del operando de mayor capacidad.

Ej.:
#include <stdio.h>
char c=2;
int i=5;
float f= 2;
double d=1.5;
int main(void) {
d= c * i + i / c + f * d; /*(int=10 + int=2 +
double=3)=>(double=15)*/
printf("%5.2lf",d);
return 0;
}

La salida será: 15.00

Bajo el contexto del ejemplo anterior, el operador de la división "/", realiza una división
entera, debido a que tanto c como i son enteros (de 8 y 16 bits respectivamente). La forma de
obtener un resultado real de esta división a partir de enteros es forzar el cambio del tipo
(promover el tipo) de uno de los operandos. Para poder hacer esto, C se vale de los moldes o
promoción (o cast), estos se aplican precediendo a la variable que queremos convertir, con el
nombre del tipo entre paréntesis, como se muestra en el siguiente ej.
char c=2;
int i=5;
printf("%4.2f", (float) i /c);
La salida será: 2.50

Continuando las analogías, en Pascal, el código sería

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 59
 program conversiondetipos;
uses crt;
var
c:shortint=2;
i:integer=5;
f:single= 2;
d:double= 1.5;
begin
d:= c * i + i div c + f * d;
writeln(d:5:2);{Salida formateada}
readkey; {evita salir del entorno de desarrollo }
end.

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 60
Entrada / salida estándar en el Lenguaje C
printf: permite enviar una salida formateada a stdout (Dispositivo de salida estándar).
La forma general es:
int printf(Cadena_con_formato [, argumento, ...]);
El prototipo de esta función se encuentra en el archivo de cabecera stdio.h.

La función printf formatea una cantidad variable de argumentos de acuerdo a lo indicado en

Cadena_con_formato, que contiene dos clases de elementos, unos son los caracteres que se
mostrarán en stdout y los otros las órdenes de formato, que definirán la forma en que se
mostrarán los argumentos. La cadena “formateada” es enviada a la salida estándar (stdout), de
no ser redireccionada stdout será por pantalla. La función devuelve la cantidad de bytes
enviados a la salida. Si ocurriese algún error devuelve una constante identificada como EOF.

Ej. :
i=4;
j=5;
printf("Si multiplico %d x %d obtengo: %d", i, j,
i*j);

La salida será:

Si multiplico 4 x 5 obtengo: 20

scanf: Es la función complementaria del printf. Esta permite recibir una cadena formateada
desde stdin (Dispositivo de entrada estándar). Como se verá es muy parecida a printf.

La forma general es:

int scanf(Cadena_con_formato [, argumento, ...]);

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 61
Ej.:
char producto[10];
unsigned int stock;
float precio;
printf("Ingrese Producto cantidad y Precio unitario:\
n");
scanf("%10s %d %f",producto,&stock,&precio);

La salida será:

Ingrese Producto cantidad y Precio

unitario:
disquetes 100 0.40 <Enter>
y de esta forma asigna los tres valores a las correspondientes variables.

Nota: Es importante introducir aquí, el concepto de bajada o

vaciado del buffer. Dado que scanf es una función que toma los
datos desde la entrada estandar (stdin), valiéndose de una memoria
intermedia (buffer). Puede ocasionar resultados impredecibles en
nuestros programas, el hecho de no vaciar el buffer (especialmente
con caracteres y con strings) y pretender el uso inmediato
posterior de la variable ingresada. Para evitar tal comportamiento
se coloca luego del cada scanf:
fflush(stdin);

Especificadores de Formato
Los especificadores de formato son los símbolos incluidos en Cadena_con_formato, que
permiten formatear la salida, no solo en las funciones printf y scanf, sino también en
funciones análogas, como:

cprintf cscanf fprintf fscanf sprintf sscanf

vfprintf vfscanf vprintf vscanf vsprintf vsscanf

algunos objetivos de estas funciones son:

fprintf: Envía salida formateada a un stream.
sprintf: Envía salida formateada a un string.
vfprintf: Envía salida formateada a un stream usando una lista de argumentos.
vprintf: Envía salida formateada a stdout usando una lista de argumentos.
vsprintf: Envía salida formateada a un string usando una lista de argumentos.

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 62
Tales descripciones son semejantes a las asociadas a scanf.

un especificador de formato usa la siguiente sintaxis:

%[bandera] [ancho] [.prec] [F|N|h|l|L] tipo

Especificador de Formato [bandera]

[bandera] Especifica

(nada) Justificación a derecha; rellena con 0 o blancos a izquierda.

- Justificación a izquierda; rellena con espacios a derecha.
+ Precede con '+' o '-' al número.
blanco Pone el signo únicamente para valores negativos.
# Si el tipo es:
c,s,d,i,u -> No tiene efecto sobre enteros ni strings
o -> Antepone 0 a arg. distinto de 0
x o X -> Antepone 0x o 0X a argumento
e, E, f , g o G -> Usa siempre punto decimal

Especificador de Formato [ancho]

[ancho] Efecto
n Rellena con blancos hasta los n caracteres o digitos
0n Rellena con ceros a izq. hasta los n caracteres o digitos
* Indica que el siguiente argumento de la lista es el ancho

Especificador de Formato [.prec]

[.prec] Efecto
(nada) Precisión por omisión.
.0 para (d,i,o,u,x) Precisión por omisión
para (e,E,f) sin punto decimal
.n A lo sumo n dígitos
* Indica que el siguiente argumento de la lista es la precisión

Especificador de Formato [F|N|h|l|L](modificador de tipo)

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 63
 Modificador Se interpreta
F El argumento es un far pointer
N El argumento es un near pointer
h d,i,o,u,x,X El argumento es un short int
l d,i,o,u,x,X El argumento es un long int
l e,E,f,g,G El argumento es un double (solo en scanf )
L e,E,f,g,G El argumento es un long doublé

Especificador de Formato tipo

tipo Forma en que sale
d Entero decimal con signo
i Idem anterior
u Entero decimal sin signo
o Entero octal sin signo
x En printf = entero hexadecimal sin signo
En scanf = entero hexadecimal
X En printf = entero hexadecimal sin signo
En scanf = hexadecimal largo
f Punto flotante [-]dddd.ddd
e Punto flotante notacion exponencial [-]d.ddd e [+/-]ddd
E Idem anterior pero utilizando la letra E
c Un carácter
s Imprime caracteres hasta '\0' o [.prec]
% El carácter %
p Si el puntero es near = YYYY; si es far = XXXX:YYYY

Aplicación de los especificadores de formato

La siguiente tabla demuestra la utilización de los especificadores de formato con la
función printf, para distintos tipos de datos, banderas, anchos, precisión y tipos.

DATOS
127 3.7 "abc" a'

6d 6o 8X 10.2e 10.2f 5s 2c ANCHO, PREC Y TIPO

%-+# +127 0177 0X7F +3.70e+00 +3.70 abc a

%-+ +127 177 7F +3.70e+00 +3.70 abc a
%-# 127 0177 0X7F 3.70e+00 3.70 abc a
P %- 127 177 7F 3.70e+00 3.70 abc a
R %+#0 +00127 000177 0X00007F +03.70e+00 +000003.70 abc a
E
%+# +127 0177 0X7F +3.70e+00 +3.70 abc a
F
I %+0 +00127 000177 0000007F +03.70e+00 +000003.70 abc a
J %+ +127 177 7F +3.70e+00 +3.70 abc a
O %#0 000127 000177 0X00007F 003.70e+00 0000003.70 abc a
%# 127 0177 0X7F 3.70e+00 3.70 abc a
%0 000127 000177 0000007F 003.70e+00 0000003.70 abc a
% 127 177 7F 3.70e+00 3.70 abc a

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 64
Ej. :
printf ("%+010.2f",3.7);
imprimirá:
+000003.70

El especificador de formato ancho indica los lugares que a lo sumo ocupará la salida,
mientras que la precisión indica la cantidad de dígitos decimales, que se mostrarán.
La utilización del asterisco para el ancho y/o la precisión, indica que el siguiente argumento
de la función es el ancho y/o la precisión. Por ejemplo:

pi= 3.14159265359;
printf("%*.*f",5,2,pi);

mostrará:

3 . 1 4

Códigos de barra invertida

Dentro de cadena_con_formato se pueden incluir ciertas constantes predefinidas
del C que tendrán determinado efecto en la salida, estas reciben el nombre de códigos de barra
invertida (el más utilizado es '\n', que, enviado a ciertas salidas, salta a la siguiente línea).
\b Backspace
\f Salto de página
\n Salto de línea
\r Retorno de carro
\t Tabulación horizontal
\" Comillas dobles
\' Comillas simples
\0 Nulo
\\ Barra invertida
\v Tabulador vertical
\a Beep
\0N Valor Octal
\xN Valor Hexadecimal
6

6
Los códigos \f y \v no tienen ningún efecto en la salida por pantalla.

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 65
Entrada / salida estándar en el Lenguaje Pascal
La función básica para la salida de datos, por pantalla es:
Write(arg1, arg2, … );
Writeln es un write que agrega al final de la secuencia de argumentos, un salto de línea y un
retorno de carro.
Esta función lo que hace es escribir argumentos (literales, constantes o variables). Un ejemplo
sería:
const cte: string= 'Mundo';
var vrbl: string;
:
vrbl := '!!!';
clrscr;
Writeln('Hola ',cte,vrbl); {literales, constantes y variables}

La salida:
Hola Mundo!!!

El write escribe en la pantalla la secuencia de argumentos “Hola ”(literal), “Mundo”

(constante) y “!!!” (variable).
Cuando se precisa manipular el formato de la salida existe dentro de la unidad sysutils, una
función que se ocupa de darles formatos a los Strings:

Format
Sintaxis:
function Format(const Fmt: string;const Args: array of
Const):string;

La función Format reemplaza todos los marcadores de posición en Fmt con los
argumentos pasados en Args y devuelve la cadena resultante. Un marcador de posición
tiene la siguiente sintaxis:

'%'[[indice ]':']['-'][ancho]['.'precision] Tipo

Vemos a continuación un código fuente que demuestra su uso:

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 66
 Program fmtdesalida;

Uses sysutils, {por Format}

crt; {por clrscr}

Var P : Pointer;
fmt,S : string;

procedure HolaMundo;
const cte: string= 'Mundo';
var vrbl: string;
begin
vrbl := '!!!';
clrscr;
Writeln('Hola ',cte,vrbl);
write('Pulse enter ');
readln;
end;

Procedure TestInteger;
begin
clrscr;
Fmt:='[%d]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
writeln('[%d]':12, ' => ', Format (Fmt,[10]));
Fmt:='[%%]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%10d]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%.4d]';S:=Format (fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%10.4d]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:d]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10d]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10.4d]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10d]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10.4d]';S:=Format (fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%-*.*d]';S:=Format (fmt,[4,5,10]);writeln(Fmt:12,' => ',s);
write('Pulse enter ');
readln;
end;

Procedure TestHexaDecimal;
begin
clrscr;
Fmt:='[%x]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%10x]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%10.4x]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:x]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10x]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10.4x]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10x]';S:=Format (Fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10.4x]';S:=Format (fmt,[10]);writeln(Fmt:12,' => ',s);
Fmt:='[%-*.*x]';S:=Format (fmt,[4,5,10]);writeln(Fmt:12,' => ',s);
write ('Pulse enter ');
readln;
end;

Procedure TestPointer;
begin
clrscr;
P:=Pointer(1234567);
Fmt:='[0x%p]';S:=Format (Fmt,[P]);writeln(Fmt:13,' => ',s);
Fmt:='[0x%10p]';S:=Format (Fmt,[P]);writeln(Fmt:13,' => ',s);
Fmt:='[0x%10.4p]';S:=Format (Fmt,[P]);writeln(Fmt:13,' => ',s);
Fmt:='[0x%0:p]';S:=Format (Fmt,[P]);writeln(Fmt:13,' => ',s);
Fmt:='[0x%0:10p]';S:=Format (Fmt,[P]);writeln(Fmt:13,' => ',s);
Fmt:='[0x%0:10.4p]';S:=Format (Fmt,[P]);writeln(Fmt:13,' => ',s);
Fmt:='[0x%0:-10p]';S:=Format (Fmt,[P]);writeln(Fmt:13,' => ',s);

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 67
 Fmt:='[0x%0:-10.4p]';S:=Format (fmt,[P]);writeln(Fmt:13,' => ',s);
Fmt:='[%-*.*p]';S:=Format (fmt,[4,5,P]);writeln(Fmt:13,' => ',s);
write ('Pulse enter ');
readln;
end;

Procedure TestString;
begin
clrscr;
Fmt:='[%s]';S:=Format(fmt, ['Un string']);Writeln(fmt:12,'=> ',s);
fmt:='[%0:s]';s:=Format(fmt, ['Un string']);Writeln(fmt:12,'=> ',s);
fmt:='[%0:18s]';s:=Format(fmt, ['Un string']);Writeln(fmt:12,'=> ',s);
fmt:='[%0:-18s]';s:=Format(fmt,['Un string']);Writeln(fmt:12,'=> ',s);
fmt:='[%0:18.12s]';s:=Format(fmt,['Un string']);Writeln(fmt:12,'=> ',s);
fmt:='[%-*.*s]';s:=Format(fmt,[18,12,'Unstring']);Writeln(fmt:12,'=>',s);
write ('Pulse enter ');
readln;
end;

Procedure TestExponential;
begin
clrscr;
Fmt:='[%e]';S:=Format (Fmt,[1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%10e]';S:=Format (Fmt,[1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%10.4e]';S:=Format (Fmt,[1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:e]';S:=Format (Fmt,[1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10e]';S:=Format (Fmt,[1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10.4e]';S:=Format (Fmt,[1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10e]';S:=Format (Fmt,[1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10.4e]';S:=Format (fmt,[1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%-*.*e]';S:=Format (fmt,[4,5,1.234]);writeln(Fmt:12,' => ',s);
write ('Pulse enter ');
readln;
end;

Procedure TestNegativeExponential;
begin
clrscr;
Fmt:='[%e]';S:=Format (Fmt,[-1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%10e]';S:=Format (Fmt,[-1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%10.4e]';S:=Format (Fmt,[-1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:e]';S:=Format (Fmt,[-1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10e]';S:=Format (Fmt,[-1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10.4e]';S:=Format (Fmt,[-1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10e]';S:=Format (Fmt,[-1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10.4e]';S:=Format (fmt,[-1.234]);writeln(Fmt:12,' => ',s);
Fmt:='[%-*.*e]';S:=Format (fmt,[4,5,-1.234]);writeln(Fmt:12,' => ',s);
write ('Pulse enter ');
readln;
end;

Procedure TestSmallExponential;
begin
clrscr;
Fmt:='[%e]';S:=Format (Fmt,[0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%10e]';S:=Format (Fmt,[0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%10.4e]';S:=Format (Fmt,[0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:e]';S:=Format (Fmt,[0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10e]';S:=Format (Fmt,[0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10.4e]';S:=Format (Fmt,[0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10e]';S:=Format (Fmt,[0.0123]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10.4e]';S:=Format (fmt,[0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%-*.*e]';S:=Format (fmt,[4,5,0.01234]);writeln(Fmt:12,' => ',s);
write ('Pulse enter ');
readln;

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 68
 end;

Procedure TestSmallNegExponential;
begin
clrscr;
Fmt:='[%e]';S:=Format (Fmt,[-0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%10e]';S:=Format (Fmt,[-0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%10.4e]';S:=Format (Fmt,[-0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:e]';S:=Format (Fmt,[-0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10e]';S:=Format (Fmt,[-0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:10.4e]';S:=Format (Fmt,[-0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10e]';S:=Format (Fmt,[-0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%0:-10.4e]';S:=Format (fmt,[-0.01234]);writeln(Fmt:12,' => ',s);
Fmt:='[%-*.*e]';S:=Format (fmt,[4,5,-0.01234]);writeln(Fmt:12,' => ',s);
write ('Pulse enter ');
readln;
end;

begin
HolaMundo;
TestInteger;
TestHexadecimal;
TestPointer;
teststring;
TestExponential;
TestNegativeExponential;
TestSmallExponential;
TestSmallNegExponential;
end.

Paradigmas y Lenguajes LSI / Paradigmas de Programación ISI

Pag. 69