Operadores aritméticos, relaciónales y lógicos; operador asignación; operador sizeof y operadores avanzados (operadores sobre bits y operador ?)

Operadores aritméticos.........................................

Los operadores aritméticos existentes en C son, ordenados de mayor a menor precedencia:
 

  

Los operadores ++, -- y % solo pueden usarse con datos de tipo int o char. El operador incremento (++), incrementa en una unidad el valor de la variable sobre la que se aplica, el operador decremento (--), decrementa en una unidad el valor de la variable, y el operador módulo (%), calcula el resto de una división de dos variables de tipo entero o carácter.

Un aspecto que conviene explicar es el hecho de que los operadores incremento y decremento pueden preceder o posceder a su operando, lo cual permite escribir, si x es una variable de tipo int, las expresiones ++x o x++. Usado de forma aislada no presenta ninguna diferencia, sin embargo, cuando se usa en una expresión existe una diferencia en el orden de ejecución del mismo. 

Cuando el operador incremento (o decremento) precede al operando, C primero realiza el incremento (o decremento), y después usa el valor del operando, realizándose la operación al contrario si el operador poscede al operando. Así, considérense el siguiente código de un programa: 

int v1=10,v2; 
v2=++v1; /*Pone 11 en v2, pues primero se
                  /*incrementa v1,  y luego asigna su valor a v2 */

Mientras que el siguiente código funciona de forma distinta:
 
int v1=10,v2; 
v2=v1++; /*Pone 10 en v2, pues primero asigna su*/                        /* valor a v2, y luego incrementa va1 */

Operadores relaciónales y lógico..........................

Los operadores relaciónales y lógicos de C, ordenados de mayor a menor prioridad son:

Los operadores relaciónales y lógicos tiene menor prioridad que los operadores aritméticos antes descritos, así , escribir 10>3+9 es equivalente a escribir 10>(3+9).

Operador asignación.............................................

El lenguaje C, a diferencia de otros lenguajes tales como Pascal, no diferencia la asignación de cualquier otro operador del lenguaje. Para C, la asignación es un operador, el llamado operador asignación (=), el cual posee la prioridad más baja de todos los operadores. Es por ello que en C podemos escribir expresiones del tipo:


if ((c=a*b)<0) 

/* if es la comprobación condicional de C, que  se vera con posterioridad */

Esta expresión asigna a la variable c el valor de a*b y devuelve su valor para compararlo con el valor constante 0. Los paréntesis son necesarios pues el operador asignación tiene la prioridad mas baja de todos los operadores. 

Operador sizeo.........................................................

El operador sizeof es un operador en tiempo de compilación. El operador sizeof devuelve el tamaño de una variable o tipo de dato durante la compilación, no durante la ejecución del programa. Veamos algunos ejemplos:
sizeof(int) devuelve el valor 2 en los sistemas operativos de 16 bits y 4 en los de 32 bits.
Si tenemos char a[20], sizeof(a) devuelve el valor 20, y si tenemos float a[6], sizeof(a) devuelve el valor 24 (4*6).

Operadores sobre bits.............................................

El lenguaje C posee operadores que actúan a nivel de bits sobre los datos, estos operadores son:

Donde los números que acompañan a los operadores << y >> indican cuantas posiciones se desplaza el operando. La prioridad de los operadores sobre bits es:

• El operador ∼ tiene la misma prioridad que los operadores ++ y .--.

• Los operadores << y >> tienen la prioridad situada entre los operadores aritméticos y los operadores relaciónales y lógicos.

• Los operadores &, ^ y | tienen la prioridad situada entre los operadores relaciónales y los operadores lógicos (&& y ||).

El operador ? ......................................................

El operador ? se usa para reemplazar las sentencias if/else (que veremos con posterioridad) de formato general:

if (condición)   
          expresión; 
else    
          expresión;









Donde expresión debe ser una expresión sencilla y no otra sentencia de C.
El operador ? es un operador ternario cuyo formato general es:

Exp1 ? Exp2 : Exp3; 

Donde Exp1, Exp2 y Exp3 son expresiones. El operador ? evalúa la expresión Exp1, si es cierta se evalúa Exp2 y si es falsa se evalúa Exp3. Veamos algunos ejemplos:
 
int x,y; 
y=(x>10) ? 100 : 200

Asignara el valor 100 a y si x es mayor de 10, y el valor 200 en caso contrario.

int t; 
(t) ? f1(t)+f2() : printf(“t vale cero”);
 
Ejecutara las funciones f1() y f2() si t es distinto de cero, y la función printf si t vale cero.

Constantes

En C, las constantes se refieren a los valores fijos que el programa no puede alterar. Algunos ejemplos de constantes de C son: 

 Existen, además, algunos tipos de constantes, distintos a los anteriores, que es necesario resaltar de forma particular. Estos tipos de constantes son las constantes hexadecimales y octales, las constantes de cadena, y las constantes de barra invertida.

Las constantes hexadecimales y octales son constantes enteras, pero definidas en base 16 (constantes hexadecimales) o en base 8 (constantes octales). Las constantes de tipo hexadecimal comienzan por los caracteres 0x seguidas del número deseado. Las constantes de tipo octal comienzan por un cero (0). Por ejemplo, son constantes hexadecimales 0x34 (52 decimal), 0xFFFF (65535 decimal); y constantes octales 011 (9 decimal), 0173 (123 decimal).

Las constantes de cadena son conjuntos de caracteres que se encierran entre comillas dobles. Por ejemplo, son constantes de cadena “Esto es una constante de cadena”, “Estos son unos apuntes de C”, etc.

Las constantes de caracteres de barra invertida se usan para introducir caracteres que es imposible introducir por el teclado (tales como retorno de carro, etc.). Estas constantes son proporcionadas por C para que sea posible introducir dichas caracteres como constantes en los programas en los cuales sea necesario. Estas constantes de caracteres de barra invertida son:

 El uso de las constantes de barra invertida es igual que el de cualquier otro carácter, así, si ch es una variable de tipo char, podemos hacer: ch=‘\t’, o ch=‘\x20’ (carácter espacio), etc., de igual forma que realizaríamos con cualquier otra constante de carácter. Además, las constantes de barra invertida pueden usarse en el interior de constantes de cadena como un carácter más, por ello, podemos poner escribir la constante de cadena: "Esta es mi primera lineaXD \n".

Especificadores de almacenamiento de los tipos de datos

Una vez explicada la declaración de variables y su alcance, vamos a proceder a explicar como es posible modificar el alcance del almacenamiento de los datos. Ello es posible realizarlo mediante los especificadores de almacenamiento. Existen cuatro especificadores de almacenamiento. Estos especificadores de almacenamiento, cuando se usan, deben preceder a la declaración del tipo de dato de la variable. Estos especificadores de almacenamiento son:

El especificador auto se usa para declarar que una variable local existe solamente mientras estemos dentro de la subrutina o bloque de programa donde se declara, pero, dado que por defecto toda variable local es auto, no suele usarse.

El especificador extern se usa en el desarrollo de programas compuestos por varios módulos. El modificador extern se usa sobre las variables globales del módulo, de forma que si una variable global se declara como extern, el compilador no crea un almacenamiento para ella en memoria, sino que, tan solo tiene en cuenta que dicha variable ya ha sido declarada en otro modulo del programa y es del tipo de dato que se indica.

El especificador static actúa según el alcance de la variable:

      • Para variables locales, el especificador static indica que dicha variable local debe almacenarse de forma permanente en memoria, tal y como si fuera una variable global, pero su alcance será el que correspondería a una variable local declarada en la subrutina o bloque. El principal efecto que provoca la declaración como static de una variable local es el hecho de que la variable conserva su valor entre llamadas a la función.

      • Para variables globales, el especificador static indica que dicha variable global es local al módulo del programa donde se declara, y, por tanto, no será conocida por ningún otro módulo del programa.

El especificador register se aplica solo a variables locales de tipo char e int. Dicho especificador indica al compilador que, caso de ser posible, mantenga esa variable en un registro de la CPU y no cree por ello una variable en la memoria. Se pueden declarar como register cuantas variables se deseen, pues el compilador ignorara dicha declaración caso de no poder ser satisfecha. El uso de variables con especificador de almacenamiento register permite colocar en registros de la CPU variables muy frecuentemente usadas, tales como contadores de bucles, etc.

Ejemplos: 

register unsigned int 
a; static float 
b; extern int c; 
static const unsigned long int d

Declaracion de variables y alcance

 En C, las variables pueden ser declaradas en cuatro lugares del módulo del programa:

• Fuera de todas las funciones del programa, son las llamadas variables globales, accesibles desde cualquier parte del programa.

• Dentro de una función, son las llamadas variables locales, accesibles tan solo por la función en las que se declaran.

• Como parámetros a la función, accesibles de igual forma que si se declararan dentro de la función.

• Dentro de un bloque de código del programa, accesible tan solo dentro del bloque donde se declara.

Esta forma de declaración puede interpretarse como una variable local del bloque donde se declara.
Para un mejor comprensión, veamos un pequeño programa de C con variables declaradas de las cuatro formas posibles:

#include <stdio.h>
int sum; /* Variable global, accesible desde cualquier parte */       
              /* del programa*/
void suma(int x) /* Variable local declarada como parámetro, */              
                           /* accesible solo por la función suma*/
{ 
          sum=sum+x; 
          return;
}
void intercambio(int *a,int *b)
{
         if (*a>*b) 
         {   
                      int inter; /* Variable local, accesible solo dentro del */               
                                     /* bloque donde se declara*/    
                      inter=*a;    
                      *a=*b;   
                      *b=inter;  
         } 
         return;
}
int main(void) /*Función principal del programa*/
{
         int contador,a=9,b=0; /*Variables locales, accesibles solo */                       
                                            /* por main*/   
         sum=0;   intercambio(&a,&b); 
         for(contador=a;contador<=b;contador++) suma(contador); 
         printf(“%d\n”,suma);
         return(0);
}

Tipos de datos, modificadores de tipo y modificadores de acceso

 En C, toda variable, antes de poder ser usada, debe ser declarada, especificando con ello el tipo de dato que almacenara.

Toda variable en C se declara de la forma:

<tipo de dato> <nombre de variable> [, nombre de variable];

Ej.
int num,num1;

En C existen cinco tipos de datos.

Modificadores

Existen cuatro modificadores de tipo, los cuales se aplican sobre los tipos de datos anteriormente citados.
 Estos modificadores, que sintácticamente anteceden a la declaración del tipo de dato, son:

Rango de valores:

Además de los modificadores de tipo existen modificadores de acceso. Los modificadores de acceso limitan el uso que puede realizarse de las variables declaradas. Los modificadores de acceso anteceden a la declaración del tipo de dato de la variable y son los siguientes:

Primero ¿Qué es?

Empezamos con un poco de teoria...........
Se que es tedioso, pero es necesario pero en caso de que sepas la historia de este puedes no ver esta entrada. Ademas no es mucho yo creo que lo soportaras XD.


El lenguaje de programación C fue creado a mediados de los años 70 por Brian Kernighan y Dennis Ritchi.

Fue probado por primera vez en un sistema UNIX en un computador  DEC PDP-11.

El lenguaje C es un lenguaje estructurado, en el mismo sentido que lo son otros lenguajes de programación tales como el lenguaje Pascal, el Ada o el Modula-2, pero no es estructurado por bloques, o sea, no es posible declarar subrutinas (pequeños trozos de programa) dentro de otras subrutinas, a diferencia de como sucede con otros lenguajes estructurados tales como el Pascal. Además, el lenguaje C no es rígido en la comprobación de tipos de datos, permitiendo fácilmente la conversión entre diferentes tipos de datos y la asignación entre tipos de datos diferentes, por ejemplo la expresión siguiente es válida en C:

float a; /*Declaro una variable para numeros reales*/
int b; /*Declaro otra variable para numero enteros*/
b=a; /*Asigno a la variable para entera el numero real*/





Todo programa de C consta, básicamente, de un conjunto de funciones, y una función llamada main, la cual es la primera que se ejecuta al comenzar el programa, llamándose desde ella al resto de funciones que compongan nuestro programa.