Comparación de Pascal y C

Otra diferencia, más sutil, es el papel del punto y coma . En Pascal, los puntos y coma separan las instrucciones individuales dentro de una instrucción compuesta; en cambio, en C, finalizan la instrucción. En C, también forman parte sintácticamente de la instrucción (transformando una expresión en una instrucción). Esta diferencia se manifiesta principalmente en dos situaciones:

• En Pascal, un punto y coma nunca puede estar directamente antes de else, mientras que en C, es obligatorio, a menos que se utilice una instrucción de bloque.
• La última instrucción antes de una " endo" untilno requiere ir seguida de un punto y coma.

Se puede colocar un punto y coma superfluo en la última línea antes de end , insertando así formalmente una instrucción vacía .

En la primera edición de C, solo hay /* block comments */. C añadió posteriormente // line comments.

En Pascal, hay y .{ block comments }(* block comments *)

C y Pascal difieren en su interpretación de mayúsculas y minúsculas. C distingue entre mayúsculas y minúsculas, mientras que Pascal no; por lo tanto, MyLabely mylabelson nombres distintos en C, pero idénticos en Pascal. En ambos lenguajes, los identificadores constan de letras y dígitos, con la regla de que el primer carácter no puede ser un dígito. En C, el guion bajo cuenta como una letra, por lo que incluso _abc es un nombre válido. Los nombres con un guion bajo inicial se utilizan a menudo para diferenciar identificadores especiales del sistema en C.

Tanto C como Pascal utilizan palabras clave (palabras reservadas para el lenguaje). Algunos ejemplos son `if` , ` while` , `const` , `for` y `goto` , palabras clave comunes a ambos lenguajes. En C, los nombres de los tipos básicos integrados también son palabras clave (por ejemplo, ` int` , `char` ) o combinaciones de palabras clave (por ejemplo, `unsigned char` ), mientras que en Pascal los nombres de los tipos integrados son identificadores normales predefinidos.

En Pascal, las definiciones de subrutinas comienzan con las palabras clave procedure (no devuelve ningún valor) o function (devuelve un valor) y las definiciones de tipo con type . En C, todas las subrutinas tienen functiondefiniciones (los procedimientos son void function) y las definiciones de tipo usan la palabra clave typedef. Ambos lenguajes usan una combinación de palabras clave y signos de puntuación para las definiciones de tipos complejos; por ejemplo, los arreglos se definen con la palabra clave array en Pascal y con signos de puntuación en C, mientras que las enumeraciones se definen con la palabra clave enumen C pero con signos de puntuación en Pascal.

En las subrutinas de Pascal, `begin` y `end` delimitan un bloque de instrucciones precedido por declaraciones locales, mientras que las funciones de C usan `{" y `}` para delimitar un bloque de instrucciones opcionalmente precedido por declaraciones  . C (antes de C99) define estrictamente que cualquier declaración debe aparecer antes de las instrucciones dentro de un bloque particular, pero permite que los bloques aparezcan dentro de otros bloques, lo cual es una forma de sortear esta restricción. Mediante la sintaxis del cuerpo de una subrutina, Pascal impone que las declaraciones aparezcan antes de las instrucciones. Pascal también permite que las definiciones de tipos y funciones —no solo las declaraciones de variables— se encapsulen mediante definiciones de funciones a cualquier nivel de profundidad.  

Las gramáticas de ambos lenguajes tienen un tamaño similar. Desde una perspectiva de implementación, la principal diferencia entre ambos lenguajes radica en que para analizar C es necesario tener acceso a una tabla de símbolos para los tipos, mientras que en Pascal solo existe una construcción de este tipo: la asignación. Por ejemplo, el fragmento de C X * Y;podría ser una declaración de Yque es un objeto cuyo tipo es un puntero a X, o una expresión de instrucción que multiplica Xy Y. En cambio, los fragmentos correspondientes de Pascal y son inherentemente inequívocos; el análisis correcto no requiere una tabla de símbolos.var Y : ^X;Z := X * Y;

Pascal requiere que todas las declaraciones de variables y funciones especifiquen su tipo explícitamente. En C tradicional, el nombre del tipo puede omitirse en la mayoría de los contextos y el tipo predeterminado int(que corresponde a integeren Pascal) se asume implícitamente (sin embargo, tales valores predeterminados se consideran una mala práctica en C y a menudo se señalan con advertencias).

C admite diferentes tamaños y modos con y sin signo para enteros mediante el uso de modificadores como long, short, signed, unsigned, etc. El significado exacto del tipo de entero resultante depende de la máquina, lo que se puede garantizar es que long intno es más corto que inty intno es más corto que short int. Sin embargo, en el estándar de C, se especifican al menos tamaños mínimos de tipos que garantizan charque sea un solo byte y intque sea al menos dos bytes.

En Pascal, se logra un resultado similar declarando un subrango de enteros (un compilador puede entonces optar por asignar una cantidad menor de almacenamiento para la variable declarada):

tipo a = 1 .. 100 ; b = - 20 .. 20 ; c = 0 .. 100000 ;

Esta característica de subrango no es compatible con C.

Una diferencia importante, aunque sutil, entre C y Pascal radica en cómo promueven las operaciones con enteros. En Pascal, el resultado de una operación está definido para todos los tipos enteros/subrangos, incluso si los resultados intermedios no caben en un entero. El resultado es indefinido solo si no cabe en el entero/subrango del lado izquierdo de la asignación. Esto puede implicar una restricción artificial en el rango de tipos enteros o puede requerir una ejecución lenta para manejar los resultados intermedios. Sin embargo, el compilador puede aprovechar los subrangos restringidos para generar código más eficiente.

En C, los operandos deben ser promovidos al tamaño del resultado requerido: los resultados intermedios no están definidos si no caben dentro del rango de los operandos promovidos. Si el rango del resultado requerido es mayor que el rango de los operandos, esto normalmente produce código lento e ineficiente, incluso con un buen compilador optimizador. Sin embargo, un compilador de C nunca está obligado ni se espera que maneje resultados intermedios fuera de rango: es responsabilidad del programador asegurarse de que todos los resultados intermedios se ajusten al rango de los operandos.

Las implementaciones de C anteriores al estándar, así como Small-C y otras, permitían que los tipos de enteros y punteros se mezclaran con relativa libertad.

En C, el tipo de carácter es charque es un tipo de entero que no es más largo que short int, . Por lo tanto, expresiones como 'x' + 1son perfectamente válidas, al igual que declaraciones como int i = 'i';y char c = 74;.

Esta naturaleza entera de char(un byte) se ilustra claramente mediante declaraciones como

unsigned char uc = 255 ; // límite común signed char sc = -128 ; // límite negativo común

Si el chartipo debe considerarse como signedo unsignedpor defecto depende de la implementación.

En Pascal, los caracteres y los enteros son tipos distintos. Las funciones integradas del compilador ord()se chr()pueden usar para convertir caracteres individuales al valor entero correspondiente del conjunto de caracteres en uso, y viceversa. Por ejemplo, en sistemas que usan el conjunto de caracteres ASCII ord('1') = 49, chr(9)es un carácter de tabulación.

En Pascal, boolean es un tipo enumerado. Los posibles valores de boolean son false y true , con un valor ordinal de false  =  0 y true  =  1. Para la conversión a entero , se utiliza ord :

i := ord ( b ) ;

No existe una función estándar para convertir un entero a un booleano ; sin embargo, la conversión es sencilla en la práctica:

b := i <> 0 ;

C tiene un tipo booleanobool , , desde C23 , pero no lo tenía antes. C usa operadores relacionales de valor binario (<, >, ==,  !=, <=, >=) que pueden considerarse booleanos en el sentido de que siempre dan como resultado cero o uno. Como todas las pruebas (&&, ||,  ?:, if , while , etc.) se realizan mediante comprobaciones de cero, falso se representa con cero, mientras que verdadero se representa con cualquier otro valor. Esto es visible en el booltipo de dato numérico definido en <stdbool.h>(anterior a C23).

Estado := Estado + [ StickyFlag ] ; ​​Estado := Estado - [ StickyFlag ] ; ​​si ( StickyFlag en Estado ) entonces ...

Estado |= StickyFlag ; Estado &= ~ StickyFlag ; si ( Estado & StickyFlag ) { ...

C tiene un modelo menos estricto de tipos de punto flotante que Pascal. En C, los enteros se pueden convertir implícitamente a números de punto flotante, y viceversa (aunque la posible pérdida de precisión puede indicarse mediante advertencias). En Pascal, los enteros se pueden convertir implícitamente a real, pero la conversión de reala integer(donde puede perderse información) debe hacerse explícitamente mediante las funciones trunc()y round(), que truncan o redondean la fracción, respectivamente.

Tanto C como Pascal incluyen tipos de enumeración. Un ejemplo en Pascal:

tipo color = ( rojo , verde , azul ) ; var a : color ;

Ejemplo de CA:

enum Color { ROJO , VERDE , AZUL };enum Color a = ROJO ;

Sin embargo, el comportamiento de los tipos en ambos lenguajes es muy diferente. En Pascal, las enumeraciones son ordinales y se analizan usando ord(), succ()y pred()las funciones y son distintas de la arrayestructura. En C, las enumeraciones se implementan como arreglos, y REDse convierte simplemente en un sinónimo de 0, GREENpara 1, BLUEpara 2, y nada impide que se asigne un valor fuera de este rango a la variable a. Además, operaciones como a = a + 1;están estrictamente prohibidas en Pascal; en su lugar, se usaría . En C, las enumeraciones se pueden convertir libremente a y desde enteros, pero en Pascal, se debe usar la función para convertir de tipos enumerados a enteros. Los enteros no se pueden convertir a tipos enumerados, pero los tipos enumerados se pueden usar en instrucciones que de otro modo usarían enteros:a := succ(a);ord()

para a := rojo a azul hacer

Tanto C como Pascal permiten arreglos de otros tipos complejos, incluyendo otros arreglos. Sin embargo, ahí terminan las similitudes entre ambos lenguajes. Los arreglos en C se definen simplemente por un tipo base y el número de elementos:

entero a [ TAMAÑO ];

y siempre están indexados desde 0hasta SIZE - 1(es decir, módulo SIZE).

En Pascal, el rango de índices a menudo se especifica mediante un subrango (como se introdujo en los tipos simples más arriba). Los diez elementos de

var a : array [ 0..9 ] de enteros ;​​

Se indexarían de 0 a 9 (al igual que en C en este caso). Los índices de los arrays pueden ser de cualquier tipo de dato ordinal , no solo rangos:

tipo TColor = ( rojo , verde , azul ) ; (* enumeración *) RGB = array [ TColor ] de 0 .. 255 ;var picture : array [ 1..640 , 1..480 ] de RGB​​​​paleta var : matriz [ byte , 0 .. 2 ] de byte

Las cadenas que constan de n > 1 caracteres se definen como matrices compactas con un rango de 1 a n.

#include <stdio.h>static char * wordlist [] = { "imprimir" , "salir" , "el" , "texto" , "mensaje" }; static int listSize = sizeof ( wordlist ) / sizeof ( wordlist [ 0 ]);for ( int i = 0 ; i < listSize ; i ++ ) { printf ( wordlist [ i ]); }for ( int i = listSize - 1 ; i >= 0 ; i -- ) { printf ( wordlist [ i ]); }

const minlist = 1 ; maxlist = 5 ; maxword = 7 ;tipo listrange = minlist .. maxlist ; wordrange = 1 .. maxword ; word = record contents : packed array [ wordrange ] of char ; length : wordrange end ; wordlist = array [ listrange ] of word ; var i : integer ; words : wordlist ;procedure CreateList ( var w : wordlist ) ; begin w [ 1 ] . contents := 'print ' ; w [ 1 ] . length := 5 ; w [ 2 ] . contents := 'out ' ; w [ 2 ] . length := 3 ; w [ 3 ] . contents := 'the ' ; w [ 3 ] . length := 3 ; w [ 4 ] . contents := 'text ' ; w [ 4 ] . length := 4 ; w [ 5 ] . contents := 'message' ; w [ 5 ] . length := 7 ; end ;begin CreateList ( palabras ) ; para i := minlist hasta maxlist hacer con palabras [ i ] hacer WriteLn ( contenido : longitud ) ; para i := maxlist hasta minlist hacer con palabras [ i ] hacer WriteLn ( contenido : longitud ) fin .

En ambos idiomas, una cadena es una secuencia primitiva de caracteres.

En Pascal, un literal de cadena de longitud n es compatible con el tipo packed array [1..n] of char. En C, una cadena generalmente tiene el tipo char[n].

Pascal no admite matrices de longitud variable, por lo que cualquier conjunto de rutinas para realizar operaciones con cadenas depende de un tamaño de cadena específico. La extensión "conformant array parameter" de Pascal, ahora estandarizada, resuelve este problema en gran medida, y muchas, o incluso la mayoría, de las implementaciones de Pascal admiten cadenas de forma nativa en el lenguaje.

Las cadenas literales de C terminan en nulo ; es decir, un carácter nulo al final actúa como centinela de fin de cadena :

// la cadena s termina en nulo const char * s = "la lluvia en España" ;

La terminación nula debe mantenerse manualmente para las variables de cadena almacenadas en matrices (esto a menudo se gestiona parcialmente mediante rutinas de biblioteca).

C carece de funciones integradas para la asignación de cadenas o matrices, por lo que la cadena no se transfiere a p, sino que se hace que p apunte a la cadena constante en la memoria.

En Pascal, a diferencia de C, el primer carácter de la cadena se encuentra en el índice 1 y no en el 0 (lo que provoca que se anteponga la longitud ). Esto se debe a que Pascal almacena la longitud de la cadena en el elemento 0 del array de caracteres. Si no se comprende bien esta diferencia, pueden surgir errores al portar o intentar integrar código objeto generado por ambos lenguajes.

El desarrollador de FreeBSD, Poul-Henning Kamp , escribiendo en ACM Queue , se referiría más tarde a la victoria de las cadenas terminadas en nulo sobre las cadenas con prefijo de longitud como "el error de un byte más costoso" de la historia. ^{[ 1 ]}

Tanto C como Pascal pueden declarar tipos de " registro ". En C, se denominan "estructuras".

struct A { int b ; char c ; };

tipo a = registro b : entero ; c : carácter ; fin ;

En Pascal, podemos usar la sentencia " with name_of_record do" para usar directamente los campos de ese registro, como variables locales, en lugar de escribir name_of_record . name_of_field . Aquí hay un ejemplo:

tipo r = registro s : cadena ; c : carácter ; fin ; var r1 : r ; comenzar con r1 hacer comenzar s := 'foo' ; c := 'b' fin fin ;

No existe una característica equivalente a `with` en C.

En C, se puede especificar la longitud exacta en bits de un campo:

struct A { unsigned int b : 3 ; unsigned int c : 1 ; };

La cantidad de almacenamiento utilizado depende de las características (por ejemplo, la alineación de palabras) del sistema de destino.

Esta característica está disponible en Pascal mediante el uso de la construcción de subrango (3 bits dan un rango de 0 a 7) en asociación con la palabra clave packed :

tipo a = registro empaquetado b : 0 .. 7 ; c : 0 .. 1 ; fin ;

Tanto C como Pascal admiten registros que pueden incluir diferentes campos superpuestos:

unión A { int a ; float b ; };

tipo a = registro caso booleano de falso : ( a : entero ) ; verdadero : ( b : real ) fin ;

Ambos procesadores de lenguaje pueden asignar a estos registros solo el espacio necesario para contener el tipo más grande en la unión/registro. En Pascal, estas construcciones se denominan registros variantes , que no deben confundirse con el tipo de dato Variant definido en Free Pascal.

La mayor diferencia entre C y Pascal es que Pascal admite el uso explícito de un "tagfield" para que el procesador del lenguaje determine si se está accediendo al componente válido del registro de variante:

tipo a = registro caso q : booleano de falso : ( a : entero ) ; verdadero : ( b : real ) fin ;

En este caso, el campo de etiqueta q debe estar configurado en el estado correcto para acceder a las partes adecuadas del registro.

Los idiomas difieren significativamente en lo que respecta a la evaluación de las expresiones, pero en general son comparables.

Pascal

1. Negación lógica:not
2. Multiplicativo:* / div mod and
3. Aditivo:+ - or
4. Relacional:= <> < > <= >= in

do

1. sufijo unario:[] () . -> ++ --
2. Prefijo unario:& * + - ! ~ ++ -- (type) sizeof
3. Multiplicativo:* / %
4. Aditivo:+ -
5. Cambio:<< >>
6. Relacional:< > <= >=
7. Igualdad:== !=
8. AND bit a bit:&
9. XOR bit a bit:^
10. OR bit a bit:|
11. Lógico y:&&
12. O lógico:||
13. Condicional:? :
14. Asignación:= += -= *= /= %= <<= >>= &= ^= |=
15. operador coma :,

En Pascal, la mayoría de los operadores cumplen diversas funciones; por ejemplo, el signo menos puede usarse para la negación, la resta o la diferencia de conjuntos (dependiendo del tipo y el contexto sintáctico), el >=operador puede usarse para comparar números, cadenas o conjuntos, etc. C utiliza símbolos de operadores específicos en mayor medida.

Cuando Niklaus Wirth diseñó Pascal, el deseo era limitar el número de niveles de precedencia (menos rutinas de análisis sintáctico, después de todo). Por lo tanto, los operadores OR y OR exclusivo se tratan como un Addop y se procesan al nivel de una expresión matemática. De manera similar, el AND se trata como un Mulop y se procesa con Term. Los niveles de precedencia son

Nótese que solo hay UN conjunto de reglas de sintaxis, que se aplica a ambos tipos de operadores. Según esta gramática, entonces, expresiones como

 x + (y Y NO z) / 3 

son perfectamente legales. Y, de hecho, lo son, al menos desde la perspectiva del analizador sintáctico. Pascal no permite la mezcla de variables aritméticas y booleanas, y este tipo de situaciones se detectan a nivel semántico, al generar el código correspondiente, en lugar de a nivel sintáctico.

Los autores de C adoptaron un enfoque diametralmente opuesto: tratan los operadores como distintos y, de hecho, en C existen no menos de 15 niveles. Esto se debe a que C también cuenta con los operadores '=', '+=' y sus variantes, '<<', '>>', '++', '--', etc. Si bien en C los operadores aritméticos y booleanos se tratan por separado, las variables no: se puede realizar una prueba booleana sobre cualquier valor entero.

var i : entero ; a : matriz empaquetada [ 1 .. 10 ] de caracteres ; ... i := 1 ; mientras ( i <= 10 ) y ( a [ i ] <> 'x' ) hacer i := i + 1 ; ...

const strlen = 10 ; var i : integer ; a : packed array [ 1..strlen ] of char ; found : boolean ; ... i : = 1 ; found := false ; while not found and ( i <= strlen ) do if ( a [ i ] = 'x' ) then found := true else i : = i + 1 ; ...

const strlen = 10 ; var i : entero ; a : matriz empaquetada [ 1..strlen ] de caracteres ; encontrado : booleano ; ... i := 1 ; repetir encontrado := a [ i ] = 'x' ; si no se encuentra, entonces incrementar ( i ) ; hasta que se encuentre o ( i > strlen ) ; ...