DOCUMENTACIÓN PARA EL TRABAJO CON LA

PLATAFORMA GUADALBOT

I.E.S VIRGEN DE LAS NIEVES Programación C para microcontroladores

Tema 2. Tipos de datos, variables y operadores

Índice de contenidosTipos de datos.......................................................................................................................................2Identificadores......................................................................................................................................2Constantes.............................................................................................................................................3Variables...............................................................................................................................................5Especificadores de tipo.........................................................................................................................6Congruencia y conversiones entre tipos. Operador cast()....................................................................7Operadores............................................................................................................................................8Jerarquía de operaciones. Precedencia de operadores........................................................................13

1

Tipos de datosEn lenguaje ensamblador todos los datos son de 8 bits sin formato que ocupan registros de la RAM, pero en un lenguaje de alto nivel como el C estos registros son tratados de acuerdo con formatos que les permiten representar números de 8, 16, 32, e incluso más bits, con o sin signo y números enteros o fracionarios, vectores, matrices y punteros. Siendo este tipo de datos los que se denominan datos básicos, fundamentales o primitivos. Usando los modificadores de formato y cualquiera de los tipos primitivos podemos obtener los denominados datos derivados. Existen otros tipos de datos, basados en los básicos, denominados datos compuestos o complejos, como son las estructuras y las uniones, que veremos más adelante.Los tipos de datos básicos del lenguaje C son:

Tipos básicosTipo

ANSI CTipo pordefectoTipo Tam.

RangoDescripción

Unsigned Signedint1 1 bit 0 a 1 No disponible Entero de 1 bit short int1

int8 8 bit 0 a 255 -128 a 127 Entero de 1 byte char unsigned int8

int16 16 bit 0 a 65535 -32.768 a 32.767 Entero de 2 bytes int int8

int32 32 bit 0 a 4294967295 -2.147.483.648 a 2.147.483.647 Entero de 4 bytes long int16

float32 32 bit - 1,5x10 +45 a 3,4x10 +38 Coma flotante long long int32

void ― ― Ausencia de tipo (sin valor) float float32

Todos los tipos, excepto float, son por defecto unsigned, sin embargo, podemos siempre poner unsigned o signed. Short y long pueden ir seguidos de la palabra clave INT sin que tenga efecto alguno. SHORT es un tipo especial que se utiliza para generar código muy eficiente para operaciones a nivel de bits y de entrada/salida. Podemos definir matrices de bits (INT1), sin embargo los punteros a bits no están permitidos.Los archivos de cabecera de los dispositivos tienen las directivas define para byte como int8 y BOOLEAN como int1.

IdentificadoresLos tipos de datos vistos son identificadores que permiten lo que es básico en programación, que es diferenciar por su nombre distintos elementos de un programa. Podemos decir que un identificador es el nombre que se le da a un elemento de un programa. Los identificadores de tipos de datos están predefinidos, es decir, forman parte del lenguaje C. Pero lógicamente nosotros también podemos definir nuestros propios identificadores, como por ejemplo variables y constantes definidas por el programador.Las reglas sintácticas del lenguaje C para asignar identificadores son:

1. Debe constar de uno o más caracteres. 2. El primer carácter debe ser siempre una letra o el carácter de subrayado, mientras

que, todos los demás pueden ser letras, dígitos o el carácter de subrayado. Las letras pueden ser mayúsculas o minúsculas pero del alfabeto inglés. No se permite el uso de caracteres especiales como la letra ñ, vocales acentuadas, etc.

3. No deben exitir dos identificadores iguales, es decir, dos elementos de un programa con el mismo nombre, lo que no indica que un identificador no pueda aparecer más de una vez en un programa.

2

Algunos identificadores válidos pueden ser:numero1 DiaMes dia_del_mes NOMBRE1 _ciudad xMes mes

Los dos últimos identificadores definidos son distintos ya que los identificadores son sensibles a minúsculas y mayúsculas.Algunos identificadores NO válidos pueden ser: 12345 //No comienza por letra o subrayado _Día //Acento no permitido numero* //Carácter no permitido dia del mes //Espacios no permitidos año //La ñ no está permitida

int //Palabra reservadaPor último indicaremos como aconsejable que los identificadores tengan un significado descriptivo o afín a lo que representan.En lenguaje C estándar las 32 palabras reservadas son las siguientes:

auto double int structbreak else long switchcase enum register typedefchar extern return unionconst float short unsignedcontinue for signed voiddefault goto sizeof volatiledo if static while

ConstantesLas constantes pueden ser de tipo entero, real, carácter, de cadena o enumerado, que estudiaremos en otro momento. Las constantes se pueden expresar bien por su valor (por ejemplo: -23 ó 15) o bien mediante un identificador. Para expresar una constante con un identificador debemos declararla previamente mediante la directiva al preprocesador #define, cuya sintaxis es:

#define <nombre de la constante> <valor de la constante>#define PI 3.141592653

#define NUMERO_E 2,7182818284 Esta directiva indica al preprocesador que debe sustituir, en el código fuente del programa, todas las ocurrencias del nombre de la constante por el valor indicado antes de la compilación. Es importante observar que en la declaración de una constante con la directiva #define no se usa el punto y coma, por lo que cada constante se debe declarar en una línea diferente.Normalmente los identificadores de las constantes se escriben en mayúsculas para poder localizarlos facilmente en el programa. Existe en C una especie de constante declarada a partir de una variable (las estudiamos seguidamente) indicando que su valor es inalterable. Para ello, se utiliza el cualificador const. Por ejemplo: const int temperatura = 15; inicializa la variable temperatura con el valor 15 y, por medio de const, se indica que su valor no puede cambiar durante la ejecución del programa, lo que hace que en cierta manera, la variable temperatura está simulando a una constante.

3

Podemos especificar constantes usando sufijos y expresando su valor en decimal, octal, hexadecimal o binario, tal y como vemos seguidamente.

Valor Expresando en Tipo Uso del sufijo305 Decimal int8 305U

o305 Octal (letra o delante del valor) long 30UL

0x305 Hexadecimal (0x) signed int16 55L

0b10010101 Binario (0b) float 3.1416F

'x' Carácter char 'Z'Una constante de tipo caracter es cualquier carácter encerrado entre comillas simples, como por ejemplo 'x' o 'Z'. El valor de una constante carácter es su valor numérico según el código ASCII. Ciertos caracteres como la comilla simple ('), la barra invertida o contrabarra (\) y otros, se representan mediante las denominadas secuencias de escape que vemos en la tabla siguiente. Estas secuencias de escape están constituidas por la barra invertida (\) seguida de otro carácter y su fin es cambiar el significado normal del carácter que sigue a la barra invertida. Si consultamos el documento "Funciones LCD_Caracteres LCD y ASCII" podemos extraer algunos de estos caracteres especiales como los que vemos a continuacón.

ConstanteValor ASCII

Lenguaje C SignificadoDec Oct Hex Bin

bel 7 0o007 0x07 0b00000111 \a Sonido de alerta

ht 9 0o011 0x09 0b00001001 \t Tabulación horizontal

nl 10 0o012 0x0A 0b00001010 \n Salto de línea

bs 8 0o010 0x08 0b00001000 \b Retroceso

\ 92 0o134 0x5C 0b01011100 \\ Barra invertida o contrabarra

' 39 0o047 0x27 0b00100111 \' Comilla simple

" 34 0o042 0x22 0b00100010 \" Comillas dobles

nul 0 0o000 0x00 0b00000000 \0 Sin operación (carácter nulo)

Un tipo de dato constante que requiere una exlicación son las cadenas de caracteres. Una cadena de caracteres es un conjunto de caracteres encerrados entre comillas dobles ("). Por ejemplo:

"Este conjunto de caracteres es una cadena"Dentro de la cadena, podemos poner caracteres en blanco y secuencias de escape como las vistas. Si queremos que aparezcan las propias comillas en la cadena debemos anteponerle la contrabarra para evitar que las interprete como final de la cadena.Indicar como muy importante que el compilador adiciona siempre un byte nulo (\0) al final de cada cadena de caracteres para señalar el final de la misma. Esto solamente es importante de cara al tamaño ya que, por ejemplo, la cadena "ordenador" no ocupa 9 bytes, sino 10, los nueve de la cadena más el del carácter nulo. Algunos ejemplos de cadenas de caracteres pueden ser:"Programación""'A'"" Esta cadena contiene espacios en blanco ""Esta cadena encierra \"otra cadena\" entre comillas y provoca un salto de línea.\n"

4

Otro tipo de dato constante es el denominado tipo enumerado (enum). Se trata de una clase especial de constantes de C que consisten en una lista de valores constantes de tipo int. Para crear una enumeración debemos definir un nuevo tipo de datos, denominado tipo enumerado y declarar una variable de este tipo. Su sintaxis es la siguiente:enum [<identificador de tipo_enumerado>]{ <nombre de la constante> [ = <valor>], ... } [lista de variables];El identificador de tipo es opcional y nos permitirá declarar más variables de tipo enumerado:[enum] <identificador de tipo_enumerado> <variable1> [,<variable2> [...] ];La lista de variables es opcional y se puede definir separada por comas en una o en varias lineas.Vamos a ver un ejemplo típico de enumeración que es el de las horas que marca un reloj.enum TipoDeHoras { una=1, dos, tres, cuatro, cinco, seis, siete, ocho, nueve, diez, once, doce, trece=1, catorce, quince, dieciseis, diecisiete, dieciocho, diecinueve, veinte, veintiuna, veintidos, veintitres, veinticuatro=0 };Vemos que las horas una y trece valen 1, dos y catorce valen 2, etc.; y que veinticuatro vale 0. Vemos en el ejemplo que una vez que se asigna un valor a un elemento de la lista los demás toman valores correlativos. En caso de no asignar ningún valor, el primer elemento toma el valor 0.Otro ejemplo típico de enumeración es el de los días de la semana, como vemos en el ejemplo siguiente.enum DiasSemana{ lunes, martes, miercoles, jueves, viernes, sabado, domingo} hoy; //declara la variable hoy del tipo enumerado DiasSemanaenum DiasSemana ayer; //declara la variable ayer del tipo enumerado DiasSemanaayer=lunes; //asigna el valor lunes a la variable ayer del tipo enumeradoayer=0; //equivalente a la asignación ayer=lunesEn este ejemplo el valor de lunes es 0, de martes 1, y así sucesivamente.

VariablesUna variable se usa para poner nombre a posiciones de memoria RAM, debiendo ser declaradas de forma obligatoria antes de poder usarlas. Para declarar una variable debemos indicar su nombre mediante un identificador válido y el tipo de dato que manejará. La sintaxis de declaración de variables es:

tipo_dato mivariable [=Valor inicial];donde tipo_dato es uno de los tipos de dato básico o complejo, del compilador o definido por el usuario y mivariable es un identificador válido cualquiera (que no sea palabra reservada) y, opcionalmente, se puede inicializar a un valor. Veamos algunos ejemplos de declaración de variables. unsigned char car1; //Variable entera de 8 bits sin signo char car2='a'; //Variable entera de 8 bits para almacenar ASCIIchar car2=97; //Línea idéntica a la anteriorchar car2=0x61; //Línea idéntica a la anterior int i; //Variable entera con signo

5

signed int i; //Línea idéntica a la anterior unsigned int x; //Variable entera sin signoTambién podemos declarar varias variables del mismo tipo en una sola línea separaándolas por comas, como por ejemplo:float area, volumen; //Variables area y volumen de tipo floatunsigned char a, b, c; //Variables a, b y c como unsigned charLas variables tienen un determinado ámbito o área donde serán accecibles. Los tipos de ámbito más usuales corresponden a las variables globales y a las variables locales. Las variables locales solamente se usan (son accesibles) en la función donde son declaradas; las variables globales son accesibles desde cualquier punto del programa. Los dos ámbitos de variables deben declararse antes de usarlas y las globales deben declararse antes de cualquier función y, por supuesto fuera de ellas. Las variables globales se inicializan a cero cuando se entra en la función main(). Las variables locales deben declararse al principio de la función donde se van a usar. A continuación vemos un boceto de programa donde se aclaran estos términos.

Especificadores de tipoAl declarar una variable podemos añadirle (anteponiendo al tipo) un especificador como const, static, volatile, extern, auto, etc. Dichos especificadores tienen diversas funciones que vamos a describir de forma breve seguidamente. Aunque las explicaciones siguientes no se entiendan perfectamente ya tendremos posteriormente los conocimientos necesarios.

Variables const: deben ser inicializadas en su declaración. Después de eso el compilador solo permitirá su lectura pero no su escritura.

Variables static: En primer lugar indicaremos que las variables static locales y globales no tienen el mismo significado. La variables locales de una función se crean cuando es llamada y se destruyen cuando se sale de ella. Los conceptor de crear y destruir debemos entenderlos como que tienen reservado espacio en memoria o que se libera dicho espacio. El significado de lo anterior es que el valor de las variables locales no tienen por que ser el mismo entre llamadas de función. Para que una variable tenga reservado espacio en memoria y su valor no cambie entre llamadas de función tenemos que declararla bien como global o bien como local estática. Por defecto las variables estáticas se inicializan a 0.

Variables volatile: Este tipo se aplica tipicamente a variables enteras y sus derivados y básicamente es una indicación al compilador para que no guarde el

6

valor de la variable en un registro del micro, sino que fuerza la actualización en memoria RAM. Esto se hace cuando existe la posibilidad de que el valor de la variable sea modificado por otro proceso que se ejecuta concurrentemente con el actual, por ejemplo cuando usamos programación con hebras o hilos o bien usamos interrupciones. Un ejemplo típico puede ser algo como lo que sigue:volatile int bandera=0; //Declaración global... while(!bandera) { //Ejecutar proceso mientras bandera sea falso... }...//Lo siguiente forma parte de una rutina de interrupción//y está en una función o método diferente del proceso.if(se_produce_interrupcion){bandera=1;}...Vemos que declaramos bandera como global para que sea acceisble al proceso y a la interrupción. Si no la declaramos como volatile el compilador puede guardar la variable en un registro del micro para acelerar el proceso lo que hará que se pierdan las modificaciones que introduzcamos mediante la interrupción, si esta se produce mientras estamos en el bucle while. Declarandola como volatile forzamos al compilador a generar código para actualizar el valor de la variable en memoria antes de verificar si es verdadero o falso.

Variables extern: Permiten el uso de variables en compilaciones múltiples.

Variables auto: El especificador auto se asume por defecto, por lo que no hay que indicarlo. La variable existe mientras esté activa la función, no se inicializan a cero y su valor desaparece cuando se sale de la función.

Congruencia y conversiones entre tipos. Operador cast()Es evidente que para poder realizar operaciones aritméticas entre variables estas tienen que ser del mismo tipo. Si, por ejemplo, tenemos una de tipo int y otra tipo float, la primera se convierte a float, o dicho de otra forma, antes de efectuarse la operación la de menor rango convierte el tipo para que su rango sea el de la de mayor rango. Se trata de una conversión o adaptación de tipos que se realiza de forma automática por parte del compilador sin necesidad de intervención alguna por parte del programador. Ante situaciones de este tipo, y aunque no tengamos que intervenir, si es necesario conocer las reglas con las que se producen estos cambios. Los tipos vistos hasta ahora se ordenan por rangos de mayor a menor de la siguiente forma:

float > unsigned long > long > unsigned int > int > charEsta conversión también se produce cuando el resultado de una expresión es asignado a una variable convirtiéndose dicho resultado al tipo de la variable. En estas conversiones debemos tener mucho cuidado porque si, por ejemplo, la variable a la que se asigna el resultado es de menor rango que el de la expresión perderemos información. Es decir, en una operación como la siguiente:

float a= 5.4,b=12.0; int y; y = a*b-3*b+7;

Cabría esperar que el valor final de y fuese 395,8 y en cambio es de 395.

7

Otro tipo de conversión es la que se realiza con el operador cast o explicita, que es una conversión de tipo, forzada por el programador. El operador cast consiste en preceder la constante, variable o expresión que se desea convertir por el tipo al que se desea convertir, encerrado entre paréntesis. Veamos un ejemplo:

Vf = (int)3.5 + ((int)I * (int)R);Tanto las variables I como R sean del tipo que sean, como la constante 3.5, de tipo float, se convierten a tipo int. El operador cast se utiliza normalmente a valores de retorno de funciones y expresiones para asegurar el tipo.Cuando usamos el operador cast con la variable R decimos que estamos haciendo 'casting' a la variable R.

OperadoresUn operador es un símbolo especial que indica al compilador que debe efectuar una operación matemática o lógica. En C existen muchos operadores de diversos tipos que vamos a describir a continuación.

Operadores AritméticosOperador Operación Ejemplos

+ Suma- Resta* Multiplicación/ División

% Módulo o resto de una división entera

++ Incremento. Suma 1 al valor de la expresión

-- Decremento. Resta 1 al valor de la expresión

sizeof() Determina el tamaño en bytes del operando

Todos estos operadores se pueden aplicar a constantes, variables y expresiones. El resultado es el que se obtiene de aplicar la operación correspondiente entre los dos operandos.El operador % se aplica solamente a constantes, variables o expresiones de tipo int y su significado lo vemos diciendo que el resultado de la operación 10%3 es 1 ya que el resto de dividir 10 entre 3 es 1. Una expresión es un conjunto de variables y constantes, como por ejemplo el siguiente polinomio: x*x/3.0-5.0*x+3.0Las expresiones pueden contener paréntesis para agrupar términos. Puede haber paréntesis contenidos dentro de otros paréntesis. El significado de los paréntesis coincide con el habitual en las expresiones matemáticas.Los operadores incrementales pueden ir inmediatamente delante o detrás de la variable. Si preceden a la variable, ésta es incrementada antes de que el valor de dicha variable sea utilizado en la expresión en la que aparece y se denomina preincremento. Si es la variable la que precede al operador, la variable es incrementada después de ser utilizada en la expresión y se denomina posincremento. El operando del operador sizeof() pueder ser el identificador o el tipo de variable que

8

debemos declarar previamente. Aunque por los paréntesis pueda parecer una función se trata de un operador. Veamos como usarlo:int a=0, t=0;t=sizeof(a); //Guarda en t el tamaño del entero at=sizeof(int); //Idéntico al anterior

Operadores de AsignaciónOperador Operación Ejemplos

= Asignación simple

+= Suma y asigna

-= Resta y asigna

*= Multiplica y asigna

/= Divide y asigna

%= Módulo y asigna

<<= Desplaza izquierda y asigna

>>= Desplaza derecha y asigna

&= AND entre bits y asigna

|= OR entre bits y asigna

^= XOR entre bits y asigna

Los operadores de asignación atribuyen a una variable (escriben en la zona de memoria asignada a la variable) el resultado de una expresión o el valor de otra variable. El operador de asignación más usado es la igualdad (que no debemos confundir con la igualdad matemática). Su sintaxis general es: NombreVariable = expresion;Se evalúa expresion y el resultado se deposita en NombreVariable, sustituyendo cualquier otro valor que hubiera en esa posición de memoria. Una posible utilización de este operador es: variable = variable + 1; Desde un punto de vista matemático esto no tiene sentido, pero sí lo tiene considerando que en realidad el operador de asignación representa una sustitución; es decir, se toma el valor de variable que tenemos en memoria, se le suma uno y el valor resultante vuelve a guardarse en memoria. El resultado ha sido incrementar el valor de variable en una unidad.

Operadores RelacionalesOperador Operación

< Menor que

> Mayor que

<= Menor o igual que

>= Mayor o igual que

== Igual

!= Distinto

?: Condicional

9

Los operadores relacionales dan al lenguaje de programación la posibilidad de considerar alternativas, es decir proceder de una forma u otra según se cumplan o no ciertas condiciones analizando si se cumplen o no esas condiciones. Nosotros estamos acostumbrados a evaluar este tipo de condiciones en el lenguaje natural evaluando condiciones usando palabras como si (yes), no (no), conectado (on), desconectado (off), verdadero (true), falso (false) y otras muchas más. En informática se ha adoptado la forma true-false obteniendo un resultado de evaluación de una condición true si esta se cumple y false en caso contrario. En lenguaje C la condición false se representa por un 0 y cualquier otro valor representa true, aunque normalmente se adopta un 1 para true.El operador condicional tiene la sintaxis siguiente:

PrimerOperando ? SegundoOperando : TercerOperando

La expresión PrimerOperando debe ser una expresión booleana y la ejecución del operador condiconal se realiza así: Se evaluá PrimerOperando y si el resultado es verdadero el resultado de la expresión condicional es SegundoOperando. Si el resultado de evaluar PrimerOperando es falso, el resultado de la expresión condicional es TercerOperando. En resumen:

Resultado de evaluar PrimerOperando Resultado del operador condiconal

TRUE SegundoOperandoFALSE TercerOperando

Operadores LógicosOperador Operación Comentarios

&& AND lógicaSi al evaluar cada operando el resultado es verdadero da como resultado verdadero. Si uno de ellos es falso, el resultado es falso. Si el primer operando es falso, el segundo no se evalúa.

|| OR lógicaSi al evaluar cada operando el resultado es falso da como resultado falso. Si uno de los operando es verdadero da como resultado verdadero. Si el primer operando es verdadero no se evalúa el segundo.

! NOT lógica El resultado es falso si al evaluar su operando el resultado es verdadero y verdadero en caso contrario.

Son operadores binarios que permiten comprobar que se cumplen simultáneamente varias condiciones, que se cumple una u otra, etc. En lenguaje C los operadores lógicos responden a las funciones del álgebra de Boole AND (&&), OR (||) y NOT (!). El resultado de efectuar una operación lógica siempre será un valor lógico verdadero o falso (0 o 1). Es decir, toda expresión numérica con valor distintos de 0 origina un resultado verdadero y cuando la expresión numérica toma valor 0 origina un resultado falso. A continuación vemos algunos ejemplos.

10

Operadores Bitwise o de bits Operador Operación Comentarios

& AND Compara dos bits generando un resultado 1 si ambos son uno, en caso contrario el resultado es 0.

| OR Compara dos bits generando un resultado 1 si ambos o cualquiera de ellos es 1, en caso contrario el resultado es 0.

^ XOR Compara dos bits generando un resultado 1 si los bits son complementarios, en caso contrario el resultado es 0.

~ Complemento a 1 Realiza el complemento a 1 (cambia 1 por 0 y 0 por 1) del operando.El caracter del operador corresponde al ASCII 126

>> Desplazamiento a la derecha

Descarta el bit menos significativo. Si es un número sin signo pone a 0 el bit más significativo, caso contrario desplaza el bit de signo por la izquierda.

<< Desplazamiento a la izquierda Descarta el bit más significativo y rellena con 0 por la derecha.

11

A continuación mostramos ejemplos de los operadores de bits.

PunterosOperador Tipo Comentarios

& Dirección Devuelve la dirección de memoria donde reside la variable.

* Indirección Devuelve el contenido de una determinada dirección de memoria

-> Puntero a estructura Da acceso a miembros de una estructura.

Puesto que se trata de operadores los vamos a introducir en este momento e indicaremos que se trata de uno de los aspectos más potentes del lenguaje C, aunque bastante complicado de dominar. La sintaxis general de estos operadores es:

*Expresion;&NombreVariable;

El operador & se denomina de dirección y lo que hace es devolver la dirección de memoria donde reside la variable, en el ejemplo NombreVariable. Por ejemplo, una vez ejecutada la siguiente sentencia: NVar1= &Nvar2; NVar1 contiene la dirección de memoria donde se guarda el contenido de NVar2.

Las variables que almacenan direcciones de otras variables se denominan punteros, y deben ser declaradas como tales, teniendo su propia sintaxis y forma de funcionamiento que veremos en otro tema.

El operador * se denomina de indirección siendo el complementario del operador de dirección &, es decir devuelve el contenido de una determinada dirección de memoria. Por ejemplo, en la siguiente sentencia NVar3=*NVar1; el puntero Nvar1 (contenido de la dirección de memoria representada por la variable Nvar1) se asigna a la variable NVar3.

12

Jerarquía de operaciones. Precedencia de operadoresLas operaciones se efectúan en un orden jerárquico que si no se tiene en cuenta al plantear y resolver una determinada operación casi siempre conduce a resultados equivocos o no deseados como estos:

Consideremos la expresión 2 + 3 * 4 1. Si hacemos primero 2+3=5 y después el producto 5*4, el resultado es 20.2. Si realizamos primero 3*4=12 y luego la suma 2+12, el resultado es 14. 3. Si notaA=6 y notaB=8 y calculamos media= notaA+notaB/2 podemos obtener dos

posibles resultados 10 y 7 según el orden de evaluación del operador.Para que el el resultado de cada expresión sea claro e inequívoco, es necesario definir las reglas que definen el orden con el que se ejecutan las operaciones en lenguaje C. Antes de plantear una formula en un programa debemos evaluar el siguiente orden de operaciones:

1. Paréntesis2. Potencias y raíces3. Multiplicaciones y divisiones4. Sumas y restas5. Dos o más de la misma jerarquía se resuelven de izquierda a derecha

En caso de duda usar siempre paréntesis.En la tabla siguiente vemos el orden descendente de precedencia de los operadores tal y como aparece en la ayuda de CCS.

(expr)!expr ~expr ++expr expr++ --expr Expr--(type)expr *expr &value sizeof(type)expr*expr expr/expr expr%exprexpr+expr expr-exprexpr<<expr expr>>exprexpr<expr expr<=expr expr>expr expr>=exprexpr==expr expr!=exprexpr&exprexpr^exprexpr | exprexpr&&exprexpr || exprexpr ? expr: exprlvalue = expr lvalue+=expr lvalue-=exprlvalue*=expr lvalue/=expr lvalue%=exprlvalue>>=expr lvalue<<=expr lvalue&=exprlvalue^=expr lvalue|=expr expr, expr

13