UNIDAD VIII Estructuras

8. Estructuras
8.1. Definición de estructuras
8.2. Inicialización de estructuras
8.3. Utilización de estructuras con funciones

UNIDAD VII Cadenas

7. Cadenas
7.1. Fundamentos de cadenas y caracteres
7.2. Funciones de manejo de cadenas y caracteres.

UNIDAD VI Apuntadores

6. Apuntadores
 6.1. Representación de un apuntador
 6.2. Precedencia de operadores de apuntadores
 6.3. Llamadas por referencia
 6.4. Utilización de apuntadores.

UNIDAD V Arreglos

5. Arreglos
5.1. Inicialización y generación de arreglos
5.2. Arreglos multidimensionales
5.3. Arreglos de caracteres
5.4. Utilización de arreglos.

UNIDAD III Control de flujo de programa

Control de flujo de programa

odo lenguaje de programación dispone de órdenes de control de flujo, que permite al programatomar decisiones lógicas segun reciba unos parámetros o otros: si llueve coge el paraguas; pero si hace sol vete a la playa.

Las posibilidades que ofrece php son:

• if/else
• if/elseif/else
• switch
• do/while
• while
• for

if else

Es la estructura de control mas corriente: La declaración if obliga a evaluar la expresión entre paréntesis; si se evalua como verdadera, se ejecuta un bloque de código; si se evalua como falsa, el bloque de código es ignorado. De esta forma nuestro script puede tomar decisiones:


<?php
$edad = "";
if ($edad >= 18) 
  {
  echo "puedes sacar el coche";
  } 
else
  {
  echo "ve en autobús";
  }
?>

Opcionalmente podemos usar una declaración else, que indicará el código que debe ejecutarse si la condición no es cumplida. La declaración else no es obligatoria, y no puede estar a su vez condicionada: else (otra condición) {...} sería inválido.


<?php if ($user == "pepe")

  {
  // código especial para el usuario pepe
  }
// código para todos los usuarios, sean o no pepe  
   ?>

El código condicionado a la cláusula if solo se evalua si la condición (que siempre debe estar entre paréntesis) se evalua como verdadera. Si no se cumple, la ejecución pasa al siguiente bloque de código.

Solo es estrictamente necesario el uso de llaves {} encerrando el código sujeto a la condición cuando ocupa mas de una línea.

Condiciones complejas

Mediante el uso de operadores podemos introducir condiciones complejas, agrupándolas con parentesis: 
<?php if (($edad >= 18)&& ($carnet_conducir == 1))
 {
 } 
  ?>

if elseif else

Exactamente igual que la anterior, solo que evaluando mas de una condición:


<?php if ($user == "pepe")
  {
  // codigo para pepe
  }
elseif ($user == "juan")
  {
  // codigo para juan
  }
  
else 
  {
  // codigo para quienes no son juan ni pepe
  }  
?>

A efectos prácticos podemos considerar que elseif y else if son lo mismo.

Operador ternario

Podemos incluir clausulas condicionales simples con una sintaxis abreviada:

(condición) ? (código a ejecutar si se da la condición) : (se ejecuta si no se da)

El primer parentesis contiene la condición; el segundo el código a ejecutar si verdadera; el tercero el código a ejecutar si falsa.


<?php

$num = 1;
($num == 1) ? (echo "$num es igual a 1") : (echo "$num no es igual a 1");
?>

equivale a :


<?php
$num = "1";

if ($num == "1")
  {
  echo "$num es igual a 1";
  }
else 
  {
  echo "$num no es igual a 1"
  }  
?>

switch

switch es una alternativa quizas mas legible cuando necesitamos evaluar una variable frente a multiples valores posibles:


<?php

$op = "a";

switch ($op) {
    case "a":
     // código que se ejecuta si $op vale "a"
    break;

    case "b":
     // código que se ejecuta si $op vale "b"
    break;
    case "c":
     // código que se ejecuta si $op vale "c"
    break;
    default:
    // código a ejecutar por defecto si no se cumple ninguna condición }
?>

El uso de break; es necesario, ya que en la estructura switch una vez cumplida una condición se ejecutan el resto de declaraciones (incluso las comprendidas en los casos que siguen). La ordenbreak evita esto saltando fuera del switch y continuando la ejecución del resto del script. Si en lugar de break usamos exit, el resto del script no se ejecutará.

Otra sintaxis alternativa

En las clausulas if-else podemos sustituir la llave de apertura { por dos puntos, y la llave de cierre por endif:


<?php
if ($user == "pepe"):
  
  // codigo para pepe
elseif ($user == "juan"):
  
  // codigo para juan
   else: 
  
  // codigo para quienes no son juan ni pepe endif;  
?>

bucles. While

A diferencia de los controles condicionales simples vistos hasta ahora, los bucles toman otro tipo de decisiones: si se da la condición, ¿cuantas veces he de ejecutar esta parte de código ?


<?php
$i=1;

while ($i <=10) {
   echo "$i<br>";
   $i++;
}
?>

Lo que traducido a lenguaje llano, viene a querer decir: mientras la variable $i tenga un valor menor de 10 ($i<=10), imprime $i y una nueva línea.

Para que el bucle funcione correctamente necesitamos cumplir dos condiciones. La primera, obvia, que $i sea inicialmente menor de 10. Si es inicialmente mayor, la condición no se cumple, y el bucle no se ejecuta.

La segunda, que a cada ejecución del código $i aumente de valor ($i++), lo que es imprescindible, ya que en caso contrario (si $i valiese siempre 1) la condición sería siempre cierta y no podríamos salir nunca del bucle.

while tiene también una sintaxis alternativa:

while (expr): sentencia ... endwhile;

Do while

La única diferencia que existe con el anterior es que aqui la condición se evalúa despues de ejecutar el código, por lo que el bucle será efectivo al menos una vez:


<?php
$i=11;
 do 
  {
  echo "$i<br>";
  $i++;
  }

while ($i <=10);
?>

For


<?php for($i=1; $i<=10; $i++) {
echo "$i<br>";
}
?>

Similar en su funcionalidad a while, el bucle for toma tres parámetros, separados los dos primeros por punto y coma: valor inicial de la variable de control, valor final y incremento de la misma.

3.1. Control secuencial
3.2. Control selectivo

Estructuras de Control Selectivas

En lo que sigue, denominaremos BLOQUE DE SENTENCIAS al conjunto de sentencias individuales incluídas dentro un par de llaves. Por ejemplo :

{
sentencia 1 ;
sentencia 2 ;
.............
sentencia n ;
}

Este conjunto se comportará sintacticamente como una sentencia simple y la llave de cierre del bloque NO debe ir seguida de punto y coma .
Un ejemplo de bloque ya visto , es el cuerpo del programa principal de la función main() .

main()
{
bloque de sentencias
}

En las proposiciones de control de flujo de programa , trabajaremos alternativamente con sentencias simples y bloques de ellas .

IF - ELSE

Esta proposición sirve para ejecutar ciertas sentencias de programa , si una expresión resulta CIERTA ú otro grupo de sentencias, si aquella resulta FALSA. Su interpretación literal sería : SI es CIERTA tal cosa , haga tal otra , si no lo es salteéla .
El caso más sencillo sería :

if(expresión)
 sentencia ;

ó

if(expresión)  sentencia ;

Cuando la sentencia que sigue al IF es única, las dos formas de escritura expresadas arriba son equivalentes . La sentencia sólo se ejecutará si el resultado de "expresión" es distinto de cero (CIERTO) , en caso contrario el programa salteará dicha sentencia , realizando la siguiente en su flujo.

Veamos unos ejemplos de las distintas formas que puede adoptar la "expresión" dentro de un IF :

if( a > b )	if( (a > b) != 0 )	las dos expresiones son idénticas, aunque a veces resulta más claro expresarla de la segunda manera, sobre todo en los primeros contactos con el lenguaje.
if(a)	if(a != 0)
if(!a)	if(a == 0 )	Las dos superiores son idénticas entre sí , al igual que las dos inferiores Obsérvese que (!a) dará un valor CIERTO sólo cuando a sea FALSO. (ver operador NEGACION )
if( a == b )
if( a = b )	/* Error */	La primera es una expresión correcta , el IF se realizará sólo si a es igual a b. En cambio la segunda es un error , ya que no se está comparando a con b , sino ASIGNANDO el valor de esta a aquella . Sin embargo, a veces puede usarse como un truco (un poco sucio) de programacion , ya que primero se realiza la asignación y luego se evalúa el resultado de esta para realizar el IF , es entonces equivalente a escribir :
a = b ;
if(a)	....................	con el ahorro de una linea de programa ( a costa de la legibilidad del mismo ).

En casos más complejos que los anteriores , la proposición IF puede estar seguida por un bloque de sentencias :

if(expresión)                        if(expresión) {

{                                          sentencia 1 ;

sentencia 1 ;                        sentencia 2 ;

sentencia 2 ;                        ...............

.............                        }

}

Las dos maneras son equivalentes , por lo que la posición de la llave de apertura del bloque queda librada al gusto del programador . El indentado de las sentencias (sangría) es también optativo , pero sumamente recomendable ,sobre todo para permitir la lectura de proposiciones muy complejas ó anidadas , como se verá luego. El bloque se ejecutará en su conjunto si la expresion resulta CIERTA. El uso del ELSE es optativo , y su aplicación resulta en la ejecución de una , ó una serie de sentencias en el caso de que la expresión del IF resulta FALSA.

Su aplicación puede verse en el ejemplo siguiente :

   if(expresión)                 if(expresión)

   {                             {

   sentencia 1 ;                 sentencia 1 ;

   sentencia 2 ;                 sentencia 2 ;

   }                             }

   sentencia 3 ;                 else

   sentencia 4 ;                 {

   sentencia 5 ;                 sentencia 3 ;

                                 sentencia 4 ;

                                 }

                                 sentencia 5 ;

En el ejemplo de la izquierda no se usa el ELSE y por lo tanto las sentencias 3 , 4 y 5 se ejecutan siempre . En el segundo caso , las sentencias 1 y 2 se ejecutan solo si la expresión es CIERTA , en ese caso las 3 y 4 NO se ejecutarán para saltarse directamente a la 5 , en el caso de que la expresión resulte FALSA se realizarán las 3 y 4 en lugar de las dos primeras y finalmente la 5 .
La proposición ELSE queda siempre asociada al IF más cercano , arriba de él .
Es común también , en caso de decisiones múltiples , el uso de anidamientos ELSE-IF de la forma indicada abajo:

if(exp.1)                        if(exp.1)

 sentencia1 ;                     sentencia1 ;

else  if(exp.2)                  else  if(exp.2)

 sentencia2 ;                          sentencia2 ;

else if(exp.3)                         else if(exp.3)

 sentencia3 ;                                sentencia3 ;

else                                   else

 sentencia5 ;                                sentencia5 ;

Si bién se suele escribir según la modalidad de la izquierda , a la derecha hemos expresado las asociaciones entre los distintos ELSE é IF por medio del tabulado del texto.
3.3. Control repetitivo.

UNIDAD IV Funciones básicas

4. Funciones básicas
4.1. Funciones de biblioteca
4.2. Definición de funciones
4.3. Declaración e invocación de funciones.

UNIDAD II Operadores, variables,constantes, tipos de datos y expresiones

 Operadores, variables,constantes, tipos de datos y expresiones
2.1. Elementos de léxico y sintaxis :
Léxico

PALABRAS RESERVADAS 

SINTAXIS

La sintaxis de un lenguaje, como lo es en el lenguaje español,

nos proporciona la forma correcta de escribir en el lenguaje.

:
2.2. Variables y constantes
Si yo deseara imprimir los resultados de multiplicar un número fijo por otro que adopta valores entre 0 y 9 , la forma normal de programar esto sería crear una CONSTANTE para el primer número y un par de VARIABLES para el segundo y para el resultado del producto. Una variable , en realidad , no es más que un nombre para identificar una (o varias) posiciones de memoria donde el programa guarda los distintos valores de una misma entidad . Un programa debe DEFINIR a todas las variables que utilizará , antes de comenzar a usarlas , a fin de indicarle al compilador de que tipo serán , y por lo tanto cuanta memoria debe destinar para albergar a cada una de ellas. Veamos el EJEMPLO 2:

EJEMPLO 2
#include 
main()
{
  int multiplicador;          /* defino multiplicador como un entero */
  int multiplicando;          /* defino multiplicando como un entero */
  int resultado;              /* defino resultado como un entero */
  multiplicador = 1000 ;      /* les asigno valores */
  multiplicando = 2 ;
  resultado = multiplicando * multiplicador ;
  printf("Resultado = %d\n", resultado);          /* muestro el resultado */
  return 0;
}

En las primeras líneas de texto dentro de main() defino mis variables como números enteros , es decir del tipo "int" seguido de un identificador (nombre) de la misma . Este identificador puede tener la cantidad de caracteres que se desee , sin embargo de acuerdo al Compilador que se use , este tomará como significantes sólo los primeros n de ellos ; siendo por lo general n igual a 32 . Es conveniente darle a los identificadores de las variables , nombres que tengan un significado que luego permita una fácil lectura del programa. Los identificadores deben comenzar con una letra ó con el símbolo de subrayado "_" , pudiendo continuar con cualquier otro caractér alfanumérico ó el símbolo "_" . El único símbolo no alfanumérico aceptado en un nombre es el "_" . El lenguaje C es sensible al tipo de letra usado ; así tomará como variables distintas a una llamada "variable" , de otra escrita como "VARIABLE". Es una convención entre los programadores de C escribir los nombres de las variables y las funciones con minúsculas, reservando las mayúsculas para las constantes.
El compilador dará como error de "Definición incorrecta" a la definición de variables con nombres del tipo de :

4pesos   $variable    primer-variable  !variable  etc.etc

NOTA: Los compiladores reservan determinados términos ó palabras claves (Keywords) para el uso sintáctico del lenguaje, tales como: asm, auto, break, case, char, do, for, etc. Si bien estas palabras están definidas para el ANSI C, los distintos compiladores extienden esta definición a OTROS términos, por lo que es aconsejable leer la tabla completa de palabras reservadas del compilador que se vaya a usar, para no utilizarlas en nombres de variables.

Vemos en las dos lineas subsiguientes a la definición de las variables, que puedo ya asignarles valores (1000 y 2) y luego efectuar el cálculo de la variable "resultado". Si prestamos ahora atención a la función printf(), ésta nos mostrará la forma de visualizar el valor de una variable. Insertada en el texto a mostrar, aparece una secuencia de control de impresión "%d" que indica, que en el lugar que ella ocupa, deberá ponerse el contenido de la variable ( que aparece luego de cerradas las comillas que marcan la finalización del texto , y separada del mismo por una coma) expresado como un un número entero decimal. Así, si compilamos y corremos el programa , obtendremos una salida :

SALIDA DEL EJEMPLO 2

Resultado = 2000

2. INICIALIZACION DE VARIABLES
Las variables del mismo tipo pueden definirse mediante una definición múltiple separandolas mediante " , " a saber :

int multiplicador, multiplicando, resultado;

Esta sentencia es equivalente a las tres definiciones separadas en el ejemplo anterior. Las variables pueden también ser inicializadas en el momento de definirse .

int multiplicador = 1000, multiplicando = 2, resultado;

De esta manera el EJEMPLO 2 podría escribirse:

EJEMPLO 2 BIS
#include 

main()

{

  int multiplicador=1000 , multiplicando=2 ;

  printf("Resultado = %d\n", multiplicando * multiplicador);

  return 0;

}

Obsérvese que en la primer sentencia se definen e inicializan simultaneamente ambas variables.La variable "resultado" la hemos hecho desaparecer ya que es innecesaria. Si analizamos la función printf() vemos que se ha reemplazado "resultado" por la operación entre las otras dos variables. Esta es una de las particularidades del lenguaje C : en los parámetros pasados a las funciones pueden ponerse operaciones (incluso llamadas a otras funciones) , las que se realizan ANTES de ejecutarse la función , pasando finalmente a esta el valor resultante de las mismas. El EJEMPLO 2 funciona exactamente igual que antes pero su código ahora es mucho más compacto y claro.
3. TIPOS DE VARIABLES
VARIABLES DEL TIPO ENTERO
En el ejemplo anterior definimos a las variables como enteros (int).
De acuerdo a la cantidad de bytes que reserve el compilador para este tipo de variable, queda determinado el "alcance" ó máximo valor que puede adoptar la misma.
Debido a que el tipo int ocupa dos bytes su alcance queda restringido al rango entre -32.768 y +32.767 (incluyendo 0 ).
En caso de necesitar un rango más amplio, puede definirse la variable como "long int nombre_de_variable" ó en forma más abreviada "long nombre_de_variable"
Declarada de esta manera, nombre_de_variable puede alcanzar valores entre - 2.347.483.648 y +2.347.483.647.
A la inversa, si se quisiera un alcance menor al de int, podría definirse "short int " ó simplemente "short", aunque por lo general, los compiladores modernos asignan a este tipo el mismo alcance que "int".
Debido a que la norma ANSI C no establece taxativamente la cantidad de bytes que ocupa cada tipo de variable, sino tan sólo que un "long" no ocupe menos memoria que un "int" y este no ocupe menos que un "short",los alcances de los mismos pueden variar de compilador en compilador , por lo que sugerimos que confirme los valores dados en este parágrafo (correspondientes al compilador de Borland C++) con los otorgados por su compilador favorito.
Para variables de muy pequeño valor puede usarse el tipo "char" cuyo alcance está restringido a -128, +127 y por lo general ocupa un único byte.
Todos los tipos citados hasta ahora pueden alojar valores positivos ó negativos y, aunque es redundante, esto puede explicitarse agregando el calificador "signed" delante; por ejemplo:

signed int

    signed long

    signed long int

    signed short

    signed short int

    signed char

Si en cambio, tenemos una variable que sólo puede adoptar valores positivos (como por ejemplo la edad de una persona ) podemos aumentar el alcance de cualquiera de los tipos , restringiéndolos a que sólo representen valores sin signo por medio del calificador "unsigned" . En la TABLA 1 se resume los alcances de distintos tipos de variables enteras

TABLA 1 VARIABLES DEL TIPO NUMERO ENTERO

TIPO	BYTES	VALOR MINIMO	VALOR MAXIMO
signed char	1	-128	127
unsigned char	1	0	255
unsigned short	2	-32.768	+32.767
unsigned short	2	0	+65.535
signed int	2	-32.768	+32.767
unsigned int	2	0	+65.535
signed long	4	-2.147.483.648	+2.147.483.647
unsigned long	4	0	+4.294.967.295

NOTA: Si se omite el calificador delante del tipo de la variable entera, éste se adopta por omisión (default) como "signed".

VARIABLES DE NUMERO REAL O PUNTO FLOTANTE
Un número real ó de punto flotante es aquel que además de una parte entera, posee fracciones de la unidad. En nuestra convención numérica solemos escribirlos de la siguiente manera : 2,3456, lamentablemente los compiladores usan la convención del PUNTO decimal (en vez de la coma) . Así el numero Pi se escribirá : 3.14159 Otro formato de escritura, normalmente aceptado, es la notación científica. Por ejemplo podrá escribirse 2.345E+02, equivalente a 2.345 * 100 ó 234.5
De acuerdo a su alcance hay tres tipos de variables de punto flotante , las mismas están descriptas en la TABLA 2

TABLA 2 TIPOS DE VARIABLES DE PUNTO FLOTANTE

TIPO	BYTES	VALOR MINIMO	VALOR MAXIMO
float	4	3.4E-38	3.4E+38
double	8	1.7E-308	1.7E+308
long double	10	3.4E-4932	3.4E+4932

Las variables de punto flotante son SIEMPRE con signo, y en el caso que el exponente sea positivo puede obviarse el signo del mismo.
4. CONVERSION AUTOMATICA DE TIPOS
Cuando dos ó mas tipos de variables distintas se encuentran DENTRO de una misma operación ó expresión matemática , ocurre una conversión automática del tipo de las variables. En todo momento de realizarse una operación se aplica la siguiente secuencia de reglas de conversión (previamente a la realización de dicha operación):

• 1) Las variables del tipo char ó short se convierten en int
• 2) Las variables del tipo float se convierten en double
• 3) Si alguno de los operandos es de mayor precisión que los demás , estos se convierten al tipo de aquel y el resultado es del mismo tipo.
• 4) Si no se aplica la regla anterior y un operando es del tipo unsigned el otro se convierte en unsigned y el resultado es de este tipo.

Las reglas 1 a 3 no presentan problemas, sólo nos dicen que previamente a realizar alguna operación las variables son promovidas a su instancia superior. Esto no implica que se haya cambiado la cantidad de memoria que las aloja en forma permanente
Otro tipo de regla se aplica para la conversión en las asignaciones.
Si definimos los términos de una asignación como,"lvalue" a la variable a la izquierda del signo igual y "rvalue" a la expresión a la derecha del mismo, es decir:

"lvalue" = "rvalue" ;

Posteriormente al cálculo del resultado de "rvalue" (de acuerdo con las reglas antes descriptas), el tipo de este se iguala al del "lvalue". El resultado no se verá afectado si el tipo de "lvalue" es igual ó superior al del "rvalue", en caso contrario se efectuará un truncamiento ó redondeo, segun sea el caso.
Por ejemplo, el pasaje de float a int provoca el truncamiento de la parte fraccionaria, en cambio de double a float se hace por redondeo.

5. ENCLAVAMIENTO DE CONVERSIONES (casting)
Las conversiones automáticas pueden ser controladas a gusto por el programador, imponiendo el tipo de variable al resultado de una operación. Supongamos por ejemplo tener:

double  d , e , f = 2.33 ;

int i = 6 ;

e = f * i ;

d = (int) ( f * i ) ;

En la primer sentencia calculamos el valor del producto (f * i) , que según lo visto anteriormente nos dará un double de valor 13.98 , el que se ha asignado a e. Si en la variable d quisiéramos reservar sólo el valor entero de dicha operación bastará con anteponer, encerrado entre paréntesis, el tipo deseado. Así en d se almacenará el número 13.00.
También es factible aplicar la fijación de tipo a una variable, por ejemplo obtendremos el mismo resultado, si hacemos:

d = (int) f * i ;

En este caso hemos convertido a f en un entero (truncando sus decimales )

6. VARIABLES DE TIPO CARACTER
El lenguaje C guarda los caracteres como números de 8 bits de acuerdo a la norma ASCII extendida , que asigna a cada caracter un número comprendido entre 0 y 255 ( un byte de 8 bits) Es común entonces que las variables que vayan a alojar caracteres sean definidas como:

char c ;

Sin embargo, también funciona de manera correcta definirla como

int c ;

Esta última opción desperdicia un poco más de memoria que la anterior ,pero en algunos casos particulares presenta ciertas ventajas . Pongamos por caso una función que lee un archivo de texto ubicado en un disco. Dicho archivo puede tener cualquier caracter ASCII de valor comprendido entre 0 y 255. Para que la función pueda avisarme que el archivo ha finalizado deberá enviar un número NO comprendido entre 0 y 255 ( por lo general se usa el -1 , denominado EOF, fin de archivo ó End Of File), en este caso dicho número no puede ser mantenido en una variable del tipo char, ya que esta sólo puede guardar entre 0 y 255 si se la define unsigned ó no podria mantener los caracteres comprendidos entre 128 y 255 si se la define signed (ver TABLA 1). El problema se obvia facilmente definiéndola como int.
Las variables del tipo caractér también pueden ser inicializadas en su definición, por ejemplo es válido escribir:

char c = 97 ;

para que c contenga el valor ASCII de la letra "a", sin embargo esto resulta algo engorroso , ya que obliga a recordar dichos códigos . Existe una manera más directa de asignar un caractér a una variable ; la siguiente inicialización es idéntica a la anterior :

char c = 'a' ;

Es decir que si delimitamos un caracter con comilla simple , el compilador entenderá que debe suplantarlo por su correspondiente código numérico .
Lamentablemente existen una serie de caracteres que no son imprimibles , en otras palabras que cuando editemos nuestro programa fuente (archivo de texto) nos resultará difícil de asignarlas a una variable ya que el editor las toma como un COMANDO y no como un caracter . Un caso típico sería el de "nueva linea" ó ENTER .
Con el fin de tener acceso a los mismos es que aparecen ciertas secuencias de escape convencionales . Las mismas estan listadas en la TABLA 3 y su uso es idéntico al de los caracteres normales , asi para resolver el caso de una asignación de "nueva linea " se escribirá:

char c = '\n' ;          /* secuencia de escape */

TABLA 3 SECUENCIAS DE ESCAPE

CODIGO	SIGNIFICADO	VALOR ASCII (decimal)	VALOR ASCII (hexadecimal)
'\n'	nueva línea	10	0x0A
'\r'	retorno de carro	13	0x0D
'\f'	nueva página	2	x0C
'\t'	tabulador horizontal	9	0x09
'\b'	retroceso (backspace)	8	0x08
'\''	comilla simple	39	0x27
'\"'	comillas	4	0x22
'\\ '	barra	92	0x5C
'\? '	interrogación	63	0x3F
'\nnn'	cualquier caracter (donde nnn es el código ASCII expresado en octal)
'\xnn'	cualquier caracter (donde nn es el código ASCII expresado en hexadecimal)

7. TAMAÑO DE LAS VARIABLES (sizeof)
En muchos programas es necesario conocer el tamaño (cantidad de bytes) que ocupa una variable, por ejemplo en el caso de querer reservar memoria para un conjunto de ellas. Lamentablemente, como vimos anteriormente este tamaño es dependiente del compilador que se use, lo que producirá, si definimos rigidamente (con un número dado de bytes) el espacio requerido para almacenarlas, un problema serio si luego se quiere compilar el programa con un compilador distinto del original
Para salvar este problema y mantener la portabilidad, es conveniente que cada vez que haya que referirse al TAMAÑO en bytes de las variables, se lo haga mediante un operador llamado "sizeof" que calcula sus requerimientos de almacenaje
Está también permitido el uso de sizeof con un tipo de variable, es decir:

sizeof(int)

sizeof(char)

sizeof(long double) , etc.

8. DEFINICION DE NUEVOS TIPOS ( typedef )
A veces resulta conveniente crear otros tipos de variables , ó redefinir con otro nombre las existentes , esto se puede realizar mediante la palabra clave "typedef" , por ejemplo:

typedef unsigned long double  enorme  ;

A partir de este momento ,las definiciones siguientes tienen idéntico significado:

unsigned long double nombre_de_variable ;

enorme nombre_de_variable ;

9. CONSTANTES
Aquellos valores que , una vez compilado el programa no pueden ser cambiados , como por ejemplo los valores literales que hemos usado hasta ahora en las inicializaciones de las variables (1000 , 2 , 'a' , '\n' , etc), suelen denominarse CONSTANTES .
Como dichas constantes son guardadas en memoria de la manera que al compilador le resulta más eficiente suelen aparecer ciertos efectos secundarios , a veces desconcertantes , ya que las mismas son afectadas por las reglas de RECONVERSION AUTOMATICA DE TIPO vista previamente.
A fin de tener control sobre el tipo de las constantes, se aplican la siguientes reglas :

• Una variable expresada como entera (sin parte decimal) es tomada como tal salvo que se la siga de las letras F ó L (mayúsculas ó minúsculas) ejemplos :
  1 : tomada como ENTERA
  1F : tomada como FLOAT
  1L : tomada como LONG DOUBLE
• Una variable con parte decimal es tomada siempre como DOUBLE, salvo que se la siga de la letra F ó L
  1.0 : tomada como DOUBLE
  1.0F : tomada como FLOAT
  1.0L : tomada como LONG FLOAT
• Si en cualquiera de los casos anteriores agregamos la letra U ó u la constante queda calificada como UNSIGNED (consiguiendo mayor alcance) :
  1u : tomada como UNSIGNED INT
  1.0UL : tomada como UNSIGNED LONG DOUBLE
• Una variable numérica que comienza con "0" es tomado como OCTAL asi : 012 equivale a 10 unidades decimales
• Una variable numérica que comienza con "0x" ó "0X" es tomada como hexadecimal : 0x16 equivale a 22 unidades decimales y 0x1A a 26 unidades decimales.

10. CONSTANTES SIMBOLICAS
Por lo general es una mala práctica de programación colocar en un programa constantes en forma literal (sobre todo si se usan varias veces en el mismo) ya que el texto se hace dificil de comprender y aún más de corregir, si se debe cambiar el valor de dichas constantes.
Se puede en cambio asignar un símbolo a cada constante, y reemplazarla a lo largo del programa por el mismo, de forma que este sea más legible y además, en caso de querer modificar el valor, bastará con cambiarlo en la asignación.
El compilador, en el momento de crear el ejecutable, reemplazará el símbolo por el valor asignado.
Para dar un símbolo a una constante bastará, en cualquier lugar del programa (previo a su uso) poner la directiva: #define, por ejemplo:

#define VALOR_CONSTANTE 342
#define PI 3.1416 

 
2.3. Tipos de datos fundamentales
Introducción a los tipos de datos

Una definición muy simple:

El tipo de un dato es el conjunto de valores que puede tomar durante el programa. Si se le intenta dar un valor fuera del conjunto se producirá un error.

La asignación de tipos a los datos tiene dos objetivos principales:

• Por un lado, detectar errores en las operaciones
• Por el otro, determinar cómo ejecutar estas operaciones

De Pascal se dice que es un lenguaje fuertemente tipeado. Esto quiere decir que todos los datos deben de tener un tipo declarado explícitamente, y además que existen ciertas restricciones en las expresiones en cuanto a los tipos de datos que en ellas intervienen.

Una ventaja de los lenguajes fuertemente tipeados es que se gasta mucho menos esfuerzo en depurar (corregir) los programas gracias a la gran cantidad de errores que detecta el compilador.

Los tipos de datos, como casi todos los objetos de Pascal, se pueden declarar. La declaración de tipos ya se comentó en el tema correspondiente a la estructura de un programa.

Clasificaciones en los tipos de datos

En Pascal existen gran variedad y cantidad de tipos de datos. Pero en este tutorial sólo se trataran los básicos para que puedas ir construyendo tus primeros programas.

Existen muchas clasificaciones para los tipos de datos, y dependiendo de la fuente que mires, te mostrarán una u otra. A continuacón tienes una de las posibles clasificaciones.:

• Dinámicos
• Estáticos

o El tipo cadena

          o Estructurados

          o Simples

                + Ordinales

                + No-ordinales 

Tipos estáticos

Casi todos los tipos de datos son estáticos, la excepción son los punteros y no se tratarán debido a su complejidad.

Que un tipo de datos sea estático quiere decir que el tamaño que ocupa en memoria no puede variar durante la ejecución del programa. Es decir, una vez declarada una variable de un tipo determinado, a ésta se le asigna un trozo de memoria fijo, y este trozo no se podrá aumentar ni disminuír.

Tipos dinámicos

Dentro de esta categoría entra sólamente el tipo puntero. Este tipo te permite tener un mayor control sobre la gestión de memoria en tus programas. Con ellos puedes manejar el tamaño de tus variables en tiempo de ejecución, o sea, cuando el programa se está ejecutando.

Los punteros quizás sean el concepto más complejo a la hora de aprender un lenguaje de programación, sobre todo si es el primero que aprendes. Debido a esto, no lo trataremos. Además, lenguajes que están muy de moda (por ejemplo Java) no permiten al programador trabajar con punteros.

Tipos simples

Como su nombre indica son los tipos básicos en Pascal. Son los más sencillos y los más fáciles de aprender. Por todo esto, serán en los que nos centremos.

Los tipos simples más básicos son: entero, lógico, carácter y real. Y la mayoría de los lenguajes de programación los soportan, no como ocurre con los estructurados que pueden variar de un lenguaje a otro.

Tipos estructurados

Mientras que una variable de un tipo simple sólo referencia a un elemento, los estructurados se refieren a colecciones de elementos.

Las colecciones de elementos que aparecen al hablar de tipos estructurados son muy variadas: tenemos colecciones ordenadas que se representan mediante el tipo array, colecciones sin orden mediante el tipo conjunto, e incluso colecciones que contienen otros tipos, son los llamados registros.

Tipos ordinales

Dentro de los tipos simples, los ordinales son los más abundantes. De un tipo se dice que es ordinal porque el conjunto de valores que representa se puede contar, es decir, podemos establecer una relación uno a uno entre sus elementos y el conjunto de los números naturales.

Dentro de los tipos simples ordinales, los más importantes son:

• El tipo entero (
• integer) El tipo lógico (boolean)
• El tipo carácter (char)

Tipos no-ordinales

Simplificando, podríamos reducir los tipos simples no-ordinales al tipo real. Este tipo nos sirve para declarar variables que pueden tomar valores dentro del conjunto de los números reales.

A diferencia de los tipos ordinales, los no-ordinales no se pueden contar. No se puede establecer una relación uno a uno entre ellos y los número naturales. Dicho de otra forma, para que un conjunto se considere ordinal se tiene que poder calcular la posición, el anterior elemento y el siguiente de un elemento cualquiera del conjunto.¿Cuál es el sucesor de 5.12? Será 5.13, o 5.120, o 5.121, …

Los tipos básicos que nos interesan

Después de ver una de las posibles clasificaciones para los tipos de datos, pasemos a ver los que nos interesan: los tipos simples. Realmente de los tipos simples veremos los más básicos, que son: integer, boolean, char y real. Además, también hablaremos un poco de las cadenas de caracteres, los llamados strings.

nota: a continuación sólo se comentará qué es cada tipo, no se explicará su declaración, esto puedes verlo si vas a la sección correspondiente.

El tipo integer (entero)

Como ya habrás leído el tipo de datos entero es un tipo simple, y dentro de estos, es ordinal. Al declarar una variable de tipo entero, estás creando una variable numérica que puede tomar valores positivos o negativos, y sin parte decimal.

Este tipo de variables, puedes utilizarlas en asignaciones, comparaciones, expresiones aritméticas, etc. Algunos de los papeles más comunes que desarrollan son:

• Controlar un bucle
• Usarlas como contador, incrementando su valor cuando sucede algo
• Realizar operaciones enteras, es decir, sin parte decimal
• Y muchas más…

A continuación tienes un ejemplo en el que aparecen dos variables enteras. Como puedes ver, en el ejemplo se muestran las dos maneras de declarar una variable de tipo entero:

type
      tContador = integer;
   var 
      i : tContador;
      n : integer;

   begin
      n := 10; (* asignamos valor al maximo *)
      i := 1;  (* asignamos valor al contador *)

      while (i <= n) do begin
        writeln(‘El valor de i es ‘,i);
        i := i + 1
      end
   end.   

El tipo boolean (lógico)

El tipo de datos lógico es el que te permite usar variables que disponen sólo de dos posibles valores: cierto o falso. Debido a esto, su utilidad salta a la vista, y no es otra que variables de chequeo. Nos sirven para mantener el estado de un objeto mediante dos valores:

• si/no
• cierto/falso
• funciona/no funciona
• on/off
• etc.

Para aclararlo, veamos un ejemplo:

type
      tLogico = boolean;
   var 
      llueve   : tLogico;   (* si llueve o no *)
      paraguas : boolean;   (* si encuentro o no el paraguas *)

   begin
      (* aqui se determinarian los valores de “llueve” y “paraguas” *) 

      if llueve and (not paraguas) then         
         writeln(‘Me quedo en casita’)
      else 
         writeln(‘Me voy a dar un paseo’)
   end.   

El tipo real (real)

Como ya has visto, Pascal soporta el conjunto entero de números. Pero no es el único, también te permite trabajar con números pertenecientes al conjunto real.

El tipo de datos real es el que se corresponde con los números reales. Este es un tipo importante para los cálculos. Por ejemplo en los estadísticos, ya que se caracterizan por tratar fundamentalmente con valores decimales.

nota: Aunque pueda que estés acostumbrado a escribir con coma los decimales, te advierto que en Pascal y en todos los lenguajes de programación se escribe con un punto. Por ejemplo: 3.1416

A continuación tienes un ejemplo en el que se utiliza el tipo real. En el puedes ver las dos formas de declarar una variable real, y tambíen el uso de una constante real. Por si tienes curiosidad, el resultado de ejecutar el programa compilado es:

El area para un radio de 3.14 es 63.6174

const
      pi = 3.1416;      
   type
      tArea = real;
   var 
      A : tArea;     (* area *)
      R : real;      (* radio *)

   begin
      R := 4.50;
      A := pi * R * R;    (* calculamos el area *)

      writeln(‘El area para un radio de ‘,R:4:2,’ es ‘,A:8:4)
   end.   

Los tipos char y string (carácter y cadena)

Con el tipo carácter puedes tener objetos que representen una letra, un número, etc. Es decir, puedes usar variables o constantes que representen un valor alfanumérico. Pero ojo, cada variable sólo podrá almacenar un carácter.

Sin embargo, con las cadenas de caracteres (strings) puedes contener en una sóla variable más de un carácter. Por ejemplo, puedes tener en una variable tu nombre.

Veamos cómo se usan ambos tipos en el siguiente ejemplo

type
      tNombre = string[10];  (* puede almacenar 10 caracteres *)
   var 
      nombre    : tNombre;  (* variable para almacenar el nombre *)
      letra_NIF : char;     (* caracter para contener la letra del NIF *)

   begin
      nombre    := ‘Beni’;
      letra_NIF := ‘L’;

      writeln(‘Mi nombre es ‘,nombre,’ y mi letra es ‘,letra_NIF)      
   end.   

Veamos un ejemplo sobre tipos de datos

A continuación se presenta un ejemplo con el que puedes interactuar para que veas de forma más amena alguno de los conceptos sobre los tipos de datos.

En el ejemplo tienes en la parte izquierda el código del programa, y en la derecha la parte con la puedes jugar. Esencialmente, lo que tienes que hacer es:

• Dar valores iniciales a las variables numero, char_A y char_B
• Y en función de estos valores y de las instrucciones que hay en el código, determinar cuál será el valor de cadena program Prueba; type

tNumero   = integer; 
     tLogico   = boolean;
     tCaracter = char;
     tCadena   = string[5];

var

numero : tNumero;
     cadena : tCadena;
     char_A, char_B     : tCaracter;
     logico_A, logico_B : tLogico;

  begin
     (* aqui se iniciarian las vars. *)
            (* … *)
     logico_A := numero > 3;
     logico_B := numero < 6;
     if logico_A and logico_B then
        cadena := char_B
     else 
        cadena := char_A;
  end.   

Los tipos básicos que nos interesan

Después de ver una de las posibles clasificaciones para los tipos de datos, pasemos a ver los que nos interesan: los tipos simples. Realmente de los tipos simples veremos los más básicos, que son: integer, boolean, char y real. Además, también hablaremos un poco de las cadenas de caracteres, los llamados strings.

nota: a continuación sólo se comentará qué es cada tipo, no se explicará su declaración, esto puedes verlo si vas a la sección correspondiente.

El tipo integer (entero)

Como ya habrás leído el tipo de datos entero es un tipo simple, y dentro de estos, es ordinal. Al declarar una variable de tipo entero, estás creando una variable numérica que puede tomar valores positivos o negativos, y sin parte decimal.

Este tipo de variables, puedes utilizarlas en asignaciones, comparaciones, expresiones aritméticas, etc. Algunos de los papeles más comunes que desarrollan son:

• Controlar un bucle
• Usarlas como contador, incrementando su valor cuando sucede algo
• Realizar operaciones enteras, es decir, sin parte decimal
• Y muchas más…

A continuación tienes un ejemplo en el que aparecen dos variables enteras. Como puedes ver, en el ejemplo se muestran las dos maneras de declarar una variable de tipo entero:

type
      tContador = integer;
   var 
      i : tContador;
      n : integer;

   begin
      n := 10; (* asignamos valor al maximo *)
      i := 1;  (* asignamos valor al contador *)

      while (i <= n) do begin
        writeln(‘El valor de i es ‘,i);
        i := i + 1
      end
   end.   

El tipo boolean (lógico)

El tipo de datos lógico es el que te permite usar variables que disponen sólo de dos posibles valores: cierto o falso. Debido a esto, su utilidad salta a la vista, y no es otra que variables de chequeo. Nos sirven para mantener el estado de un objeto mediante dos valores:

• si/no
• cierto/falso
• funciona/no funciona
• on/off
• etc.

Para aclararlo, veamos un ejemplo:

type
      tLogico = boolean;
   var 
      llueve   : tLogico;   (* si llueve o no *)
      paraguas : boolean;   (* si encuentro o no el paraguas *)

   begin
      (* aqui se determinarian los valores de “llueve” y “paraguas” *) 

      if llueve and (not paraguas) then         
         writeln(‘Me quedo en casita’)
      else 
         writeln(‘Me voy a dar un paseo’)
   end.   

El tipo real (real)

Como ya has visto, Pascal soporta el conjunto entero de números. Pero no es el único, también te permite trabajar con números pertenecientes al conjunto real.

El tipo de datos real es el que se corresponde con los números reales. Este es un tipo importante para los cálculos. Por ejemplo en los estadísticos, ya que se caracterizan por tratar fundamentalmente con valores decimales.

nota: Aunque pueda que estés acostumbrado a escribir con coma los decimales, te advierto que en Pascal y en todos los lenguajes de programación se escribe con un punto. Por ejemplo: 3.1416

A continuación tienes un ejemplo en el que se utiliza el tipo real. En el puedes ver las dos formas de declarar una variable real, y tambíen el uso de una constante real. Por si tienes curiosidad, el resultado de ejecutar el programa compilado es:

El area para un radio de 3.14 es 63.6174 


   const
      pi = 3.1416;      
   type
      tArea = real;
   var 
      A : tArea;     (* area *)
      R : real;      (* radio *)

   begin
      R := 4.50;
      A := pi * R * R;    (* calculamos el area *)

      writeln(‘El area para un radio de ‘,R:4:2,’ es ‘,A:8:4)
   end.   

Los tipos char y string (carácter y cadena)

Con el tipo carácter puedes tener objetos que representen una letra, un número, etc. Es decir, puedes usar variables o constantes que representen un valor alfanumérico. Pero ojo, cada variable sólo podrá almacenar un carácter.

Sin embargo, con las cadenas de caracteres (strings) puedes contener en una sóla variable más de un carácter. Por ejemplo, puedes tener en una variable tu nombre.

Veamos cómo se usan ambos tipos en el siguiente ejemplo

type
      tNombre = string[10];  (* puede almacenar 10 caracteres *)
   var 
      nombre    : tNombre;  (* variable para almacenar el nombre *)
      letra_NIF : char;     (* caracter para contener la letra del NIF *)

   begin
      nombre    := ‘Beni’;
      letra_NIF := ‘L’;

      writeln(‘Mi nombre es ‘,nombre,’ y mi letra es ‘,letra_NIF)      
   end.   

Veamos un ejemplo sobre tipos de datos

A continuación se presenta un ejemplo con el que puedes interactuar para que veas de forma más amena alguno de los conceptos sobre los tipos de datos.

En el ejemplo tienes en la parte izquierda el código del programa, y en la derecha la parte con la puedes jugar. Esencialmente, lo que tienes que hacer es:

• Dar valores iniciales a las variables numero, char_A y char_B
• Y en función de estos valores y de las instrucciones que hay en el código, determinar cuál será el valor de cadena program Prueba; type

tNumero   = integer; 
     tLogico   = boolean;
     tCaracter = char;
     tCadena   = string[5];

var

numero : tNumero;
     cadena : tCadena;
     char_A, char_B     : tCaracter;
     logico_A, logico_B : tLogico;

  begin
     (* aqui se iniciarian las vars. *)
            (* … *)
     logico_A := numero > 3;
     logico_B := numero < 6;
     if logico_A and logico_B then
        cadena := char_B
     else 
        cadena := char_A;
  end.   

2.4. Operadores y precedencia
2.5. Construcción de expresiones
2.6. Sentencias y bloques de sentencias de programa.
2.7. Funciones básicas de entrada y salida.