9. Operadores, expresiones y sentencias.

9.2. Operadores.
9.3. Expresiones.
9.4. Reglas de precedencia y asociatividad.
9.5. Sentencias.
9.6. Tablas-resumen.

9.2. Operadores.

Un operador es un carácter o grupo de caracteres que actúa sobre una, dos o más variables para realizar una determinada operación con un determinado resultado.

Ejemplos típicos de operadores son la suma (+), la diferencia (-), el producto (*), etc.

Los operadores pueden ser unarios, binarios y ternarios, según actúen sobre uno, dos o tres operandos, respectivamente.

En C existen muchos operadores de diversos tipos (éste es uno de los puntos fuertes del lenguaje), que se verán a continuación.

9.2.1. Operadores aritméticos.

Los operadores aritméticos son los más sencillos de entender y de utilizar. Todos ellos son operadores binarios.

En C se utilizan los cinco operadores siguientes:

• Suma: +
• Resta: -
• Multiplicación: *
• División: /
• Módulo o Resto: %

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 único operador que requiere una explicación adicional es el operador resto %. En realidad su nombre completo es resto de la división entera. Este operador se aplica solamente a constantes, variables o expresiones de tipo int. Aclarado esto, su significado es evidente: 23%4 es 3, puesto que el resto de dividir 23 por 4 es 3.

Si a%b es cero, a es múltiplo de b.

Como se verá más adelante, una expresión es un conjunto de variables y constantes (y también otras expresiones más sencillas) relacionadas mediante distintos operadores. Un ejemplo de expresión en la que intervienen operadores aritméticos es el siguiente polinomio en la variable x:

5.0 + 3.0*x – x*x/2.0

Las expresiones pueden contener paréntesis (...) que agrupan a algunos de sus 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, con algunas características importantes que se verán más adelante. En ocasiones, la introducción de espacios en blanco mejora la legibilidad de las expresiones.

9.2.2. Operadores de asignación.

Los operadores de asignación atribuyen a una variable (es decir, depositan en la zona de memoria correspondiente a dicha variable) el resultado de una expresión o el valor de otra variable.

El operador de asignación más utilizado es el operador de igualdad (=), que no debe ser confundido con la igualdad matemática. Su forma general es:

nombre_de_variable = expresion;

Cuyo funcionamiento es como sigue: se evalúa expresion y el resultado se deposita en nombre_de_variable, sustituyendo cualquier otro valor que hubiera en esa posición de memoria anteriormente. Una posible utilización de este operador es como sigue:

variable = variable + 1;

Desde el punto de vista matemático este ejemplo no tiene sentido (¡Equivale a 0 = 1!), pero sí lo tiene considerando que en realidad el operador de asignación (=) representa una sustitución; en efecto, se toma el valor de variable contenido en la memoria, se le suma una unidad y el valor resultante vuelve a depositarse en memoria en la zona correspondiente al identificador variable, sustituyendo al valor que había anteriormente. El resultado ha sido incrementar el valor de variable en una unidad.

Así pues, una variable puede aparecer a la izquierda y a la derecha del operador (=). Sin embargo, a la izquierda del operador de asignación (=) no puede haber nunca una expresión: tiene que ser necesariamente el nombre de una variable. Es incorrecto, por tanto, escribir algo así como:

a + b = c; // INCORRECTO

Existen otros cuatro operadores de asignación (+=, -=, *= y /=) formados por los 4 operadores aritméticos seguidos por el carácter de igualdad. Estos operadores simplifican algunas operaciones recurrentes sobre una misma variable. Su forma general es:

variable op= expresion;

Donde op representa cualquiera de los operadores (+ - * /).

La expresión anterior es equivalente a:

variable = variable op expresion;

A continuación se presentan algunos ejemplos con estos operadores de asignación:

//equivale a: peso += 1; peso = peso+1; rango /= 2.0; rango = rango /2.0 x *= 3.0 * y – 1.0; x = x * (3.0 * y – 1.0)

9.2.3. Operadores incrementales.

Los operadores incrementales (++) y (--) son operadores unarios que incrementan o disminuyen en una unidad el valor de la variable a la que afectan. Estos operadores 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.

Si es la variable la que precede al operador, la variable es incrementada después de ser utilizada en la expresión.

A continuación se presenta un ejemplo de estos operadores:

i = 2; j = 2; m = i++; /* despues de ejecutarse esta sentencia m=2 e i=3*/ n = ++j; /* despues de ejecutarse esta sentencia n=3 y j=3*/

Estos operadores son muy utilizados. Es importante entender muy bien por qué los resultados m y n del ejemplo anterior son diferentes.

9.2.4. Operadores relacionales.

Una característica imprescindible de cualquier lenguaje de programación es la de considerar alternativas, esto es, la de proceder de un modo u otro según se cumplan o no ciertas condiciones.

Los operadores relacionales permiten estudiar si se cumplen o no esas condiciones. Así pues, estos operadores producen un resultado u otro según se cumplan o no algunas condiciones que se verán a continuación.

En el lenguaje natural, existen varias palabras o formas de indicar si se cumple o no una determinada condición. En inglés estas formas son (yes, no), (on, off), (true, false), etc. En Informática se ha hecho bastante general el utilizar la última de las formas citadas: (true, false). Si una condición se cumple, el resultado es true; en caso contrario, el resultado es false.

En C un 0 representa la condición de false, y cualquier número distinto de 0 equivale a la condición true. Cuando el resultado de una expresión es true y hay que asignar un valor concreto distinto de cero, por defecto se toma un valor unidad. Los operadores relacionales de C son los siguientes:

• Igual que: ==
• Menor que: <
• Mayor que: >
• Menor o igual que: <=
• Mayor o igual que: >=
• Distinto que: !=

Todos los operadores relacionales son operadores binarios (tienen dos operandos), y su forma general es la siguiente:

expresion1 op expresion2

Donde op es uno de los operadores (==, <, >, <=, >=, !=). El funcionamiento de estos operadores es el siguiente: se evalúan expresion1 y expresion2, y se comparan los valores resultantes. Si la condición representada por el operador relacional se cumple, el resultado es 1; si la condición no se cumple, el resultado es 0.

A continuación se incluyen algunos ejemplos de estos operadores aplicados a constantes:

(2==1) /* resultado=0 porque la condición no se cumple*/ (3<=3) /* resultado=1 porque la condición se cumple*/ (3<3) /* resultado=0 porque la condición no se cumple*/ (1!=1) /* resultado=0 porque la condición no se cumple*/

9.2.5. Operadores lógicos.

Los operadores lógicos son operadores binarios que permiten combinar los resultados de los operadores relacionales, comprobando que se cumplen simultáneamente varias condiciones, que se cumple una u otra, etc.

El lenguaje C tiene dos operadores lógicos: el operador Y (&&) y el operador O (||). En inglés son los operadores and y or. Su forma general es la siguiente:

expresion1 || expresion2 expresion1 && expresion2

El operador && devuelve un 1 si tanto expresion1 como expresion2 son verdaderas (distintas de 0), y 0 en caso contrario, es decir si una de las dos expresiones o las dos son falsas (iguales a 0); por otra parte, el operador || devuelve 1 si al menos una de las expresiones es cierta.

Es importante tener en cuenta que los compiladores de C tratan de optimizar la ejecución de estas expresiones, lo cual puede tener a veces efectos no deseados. Por ejemplo: para que el resultado del operador && sea verdadero, ambas expresiones tienen que ser verdaderas; si se evalúa expresion1 y es falsa, ya no hace falta evaluar expresion2, y de hecho no se evalúa. Algo parecido pasa con el operador ||: si expresion1 es verdadera, ya no hace falta evaluar expresion2.

Los operadores && y || se pueden combinar entre sí (quizás agrupados entre paréntesis), dando a veces un código de más difícil interpretación. Por ejemplo:

(2==1) || (-1==-1) // el resultado es 1 (2==2) && (3==-1) // el resultado es 0 ((2==2) && (3==3)) || (4==0) // el resultado es 1 ((6==6) || (8==0)) && ((5==5) &&(3==2)) // el resultado es 0

9.2.6. Operadores de manejo de bits.

Los operadores de manejo de bits permiten actuar sobre los operandos a nivel de bits. Los operandos sólo pueden ser de tipo entero, pues es el único caso en que tendrán sentido estas operaciones.

En C los operadores de bits son:

• & (AND)
• | (OR)
• ^ (XOR)
• ~ (NOT)
• << (desplazamiento hacia la izquierda)
• >> (desplazamiento hacia la derecha).

Estas operaciones se realizan bit a bit de los operandos. Por ejemplo:

4&12 // 0100 & 1100 = 0100 =4 4|8 // 0100 | 1000 = 1100 =12 8>>3 //desplaza 3 posiciones a la derecha los bits del // número 8 en binario 0000000000001000 resulta: // 0000000000000001 . los tres bits de la derecha se pierden

También se pueden utilizar oeradores de asignación del tipo &= , |= y ^=.

9.2.7. Otros operadores.

Además de los operadores vistos hasta ahora, el lenguaje C dispone de otros operadores. En esta sección se describen algunos operadores unarios adicionales.

9.2.7.1. Operador menos (–).

El efecto de este operador en una expresión es cambiar el signo de la variable o expresión que le sigue. Recuérdese que en C no hay constantes numéricas negativas. La forma general de este operador es: -expresion.

9.2.7.2. Operador más (+).

Este es un nuevo operador unario introducido en el ANSI C, y que tiene como finalidad la de servir de complemento al operador (–) visto anteriormente. Se puede anteponer a una variable o expresión como operador unario, pero en realidad no hace nada.

9.2.7.3. Operador sizeof().

Este es el operador de C con el nombre más largo. Puede parecer una función, pero en realidad es un operador. La finalidad del operador sizeof() es devolver el tamaño, en bytes, del tipo de variable introducida entre los paréntesis. Recuérdese que este tamaño depende del compilador y del tipo de ordenador que se está utilizando, por lo que es necesario disponer de este operador para producir código portable. Por ejemplo:

var_1 = sizeof(double); // var_1 contiene el tamaño de una variable double

9.2.7.4. Operador negación lógica (!).

Este operador devuelve un cero (false) si se aplica a un valor distinto de cero (true), y devuelve un 1 (true) si se aplica a un valor cero (false). Su forma general es: !expresion.

9.2.7.5. Operador coma (,).

Los operandos de este operador son expresiones, y tiene la forma general:

expresion = expresion_1, expresion_2

En este caso, expresion_1 se evalúa primero, y luego se evalúa expresion_2. El resultado global es el valor de la segunda expresión, es decir de expresion_2. Este es el operador de menos precedencia de todos los operadores de C. Como se explicará más adelante, su uso más frecuente es para introducir expresiones múltiples en la sentencia for.

9.2.7.6. Operadores dirección (&) e indirección (*).

Aunque estos operadores se introduzcan aquí de modo circunstancial, su importancia en el lenguaje C es absolutamente esencial, resultando uno de los puntos más fuertes (y quizás más difíciles de dominar) de este lenguaje. La forma general de estos operadores es la siguiente:

*expresion; &variable;

El operador dirección & devuelve la dirección de memoria de la variable que le sigue.

Por ejemplo:

variable_1 = &variable_2;

Después de ejecutarse esta instrucción variable_1 contiene la dirección de memoria donde se guarda el contenido de variable_2. Las variables que almacenan direcciones de otras variables se denominan punteros (o apuntadores), deben ser declaradas como tales, y tienen su propia aritmética y modo de funcionar. Se verán con detalle un poco más adelante.

No se puede modificar la dirección de una variable, por lo que no están permitidas operaciones en las que el operador & figura a la izda del operador (=), al estilo de:

// No es correcto &variable_1 = nueva_direccion;

El operador indirección * es el operador complementario del &. Aplicado a una expresión que represente una dirección de memoria (puntero) permite hallar el contenido o valor almacenado en esa dirección. Por ejemplo:

variable_3 = *variable_1;

El contenido de la dirección de memoria representada por la variable de tipo puntero variable_1 se recupera y se asigna a la variable variable_3.

Como ya se ha indicado, las variables puntero y los operadores dirección (&) e indirección (*) serán explicados con mucho más detalle en una sección posterior.

9.3. Expresiones.

Ya han aparecido algunos ejemplos de expresiones del lenguaje C en las secciones precedentes. Una expresión es una combinación de variables y/o constantes, y operadores. La expresión es equivalente al resultado que proporciona al aplicar sus operadores a sus operandos. Por ejemplo, 1+5 es una expresión formada por dos operandos (1 y 5) y un operador (el +); esta expresión es equivalente al valor 6, lo cual quiere decir que allí donde esta expresión aparece en el programa, en el momento de la ejecución es evaluada y sustituida por su resultado.

Una expresión puede estar formada por otras expresiones más sencillas, y puede contener paréntesis de varios niveles agrupando distintos términos.

En C existen distintos tipos de expresiones.

9.3.1. Expresiones aritméticas.

Están formadas por variables y/o constantes, y distintos operadores aritméticos e incrementales (+, -, *, /, %, ++, --). Como se ha dicho, también se pueden emplear paréntesis de tantos niveles como se desee, y su interpretación sigue las normas aritméticas convencionales. Por ejemplo, la solución de la ecuación de segundo grado, se escribe, en C en la forma:

x=(-b+sqrt((b*b)-(4*a*c)))/(2*a);

Donde, estrictamente hablando, sólo lo que está a la derecha del operador de asignación (=) es una expresión aritmética. El conjunto de la variable que está a la izquierda del signo (=), el operador de asignación, la expresión aritmética y el carácter (;) constituyen una sentencia. En la expresión anterior aparece la llamada a la función de librería sqrt(), que tiene como valor de retorno la raíz cuadrada de su único argumento.

En las expresiones se pueden introducir espacios en blanco entre operandos y operadores; por ejemplo, la expresión anterior se puede escribir también de la forma:

x = (-b + sqrt((b * b) - (4 * a * c)))/(2 * a);

9.3.2. Expresiones lógicas.

Los elementos con los que se forman estas expresiones son valores lógicos; verdaderos (true, o distintos de 0) y falsos (false, o iguales a 0), y los operadores lógicos ||, && y !. También se pueden emplear los operadores relacionales (<, >, <=, >=, ==, !=) para producir estos valores lógicos a partir de valores numéricos. Estas expresiones equivalen siempre a un valor 1 (true) o a un valor 0 (false). Por ejemplo:

a = ((b>c)&&(c>d))||((c==e)||(e==b));

Donde de nuevo la expresión lógica es lo que está entre el operador de asignación (=) y el (;). La variable a valdrá 1 si b es mayor que c y c mayor que d, ó si c es igual a e ó e es igual a b.

9.3.3. Expresiones generales.

Una de las características más importantes (y en ocasiones más difíciles de manejar) del C es su flexibilidad para combinar expresiones y operadores de distintos tipos en una expresión que se podría llamar general, aunque es una expresión absolutamente ordinaria de C.

Recuérdese que el resultado de una expresión lógica es siempre un valor numérico (un 1 ó un 0).

Esto permite que cualquier expresión lógica pueda aparecer como sub-expresión en una expresión aritmética. Recíprocamente, cualquier valor numérico puede ser considerado como un valor lógico: true si es distinto de 0 y false si es igual a 0.

Esto permite introducir cualquier expresión aritmética como sub-expresión de una expresión lógica. Por ejemplo:

(a - b*2.0) && (c != d)

A su vez, el operador de asignación (=), además de introducir un nuevo valor en la variable que figura a su izda, deja también este valor disponible para ser utilizado en una expresión más general. Por ejemplo, supóngase el siguiente código que inicializa a 1 las tres variables a, b y c:

a = b = c = 1;

Que equivale a: a = (b = (c = 1)); En realidad, lo que se ha hecho ha sido lo siguiente. En primer lugar se ha asignado un valor unidad a c; el resultado de esta asignación es también un valor unidad, que está disponible para ser asignado a b; a su vez el resultado de esta segunda asignación vuelve a quedar disponible y se puede asignar a la variable a.

9.4. Reglas de precedencia y asociatividad.

El resultado de una expresión depende del orden en que se ejecutan las operaciones. El siguiente ejemplo ilustra claramente la importancia del orden. Considérese la expresión:

3 + 4 * 2

Si se realiza primero la suma (3+4) y después el producto (7*2), el resultado es 14; si se realiza primero el producto (4*2) y luego la suma (3+8), el resultado es 11.

Con objeto de que el resultado de cada expresión quede claro e inequívoco, es necesario definir las reglas que definen el orden con el que se ejecutan las expresiones de C.

Existen dos tipos de reglas para determinar este orden de evaluación:

• Reglas de precedencia.
• Asociatividad.

Además, el orden de evaluación puede modificarse por medio de paréntesis, pues siempre se realizan primero las operaciones encerradas en los paréntesis más interiores.

Los distintos operadores de C se ordenan según su distinta precedencia o prioridad; para operadores de la misma precedencia o prioridad, en algunos el orden de ejecución es de izquierda a derecha, y otros de derecha a izquierda (se dice que se asocian de izquierda a derecha, o de derecha a izquierda). A este orden se le llama asociatividad.

En la tabla se muestra la precedencia (disminuyendo de arriba abajo) y la asociatividad de los operadores de C. En dicha Tabla se incluyen también algunos operadores que no han sido vistos hasta ahora.

Precedencia	Asociatividad
() [] -> .	izda a dcha
++ -- ! sizeof (tipo) +(unario) -(unario) *(indir.) &(dirección)	dcha a izda
* / %	izda a dcha
+ -	izda a dcha
< <= > >=	izda a dcha
== !=	izda a dcha
&&	izda a dcha
||	izda a dcha
?:	dcha a izda
= += -= *= /=	dcha a izda
, (operador coma)	izda a dcha

En la Tabla anterior se indica que el operador (*) tiene precedencia sobre el operador (+). Esto quiere decir que, en ausencia de paréntesis, el resultado de la expresión 3+4*2 es 11 y no 14. Los operadores binarios (+) y (-) tienen igual precedencia, y asociatividad de izda a dcha. Eso quiere decir que en la siguiente expresión:

a-b+d*5.0+u/2.0 // (((a-b)+(d*5.0))+(u/2.0))

El orden de evaluación es el indicado por los paréntesis en la parte derecha de la línea (Las últimas operaciones en ejecutarse son las de los paréntesis más exteriores).

9.5. Sentencias.

Las expresiones de C son unidades o componentes elementales de unas entidades de rango superior que son las sentencias. Las sentencias son unidades completas, ejecutables en sí mismas. Ya se verá que muchos tipos de sentencias incorporan expresiones aritméticas, lógicas o generales como componentes de dichas sentencias.

9.5.1. Sentencias simples.

Una sentencia simple es una expresión de algún tipo terminada con un carácter (;). Un caso típico son las declaraciones o las sentencias aritméticas. Por ejemplo:

float real; espacio = espacio_inicial + velocidad * tiempo;

9.5.2. Sentencia vacía ó nula.

En algunas ocasiones es necesario introducir en el programa una sentencia que ocupe un lugar, pero que no realice ninguna tarea. A esta sentencia se le denomina sentencia vacía y consta de un simple carácter (;). Por ejemplo:

for (a=0;a<5000;a++);

La sentencia anterior produce un retardo, no hace nada (;) hasta que a=5000.

9.5.3. Sentencias compuestas o bloques.

Muchas veces es necesario poner varias sentencias en un lugar del programa donde debería haber una sola. Esto se realiza por medio de sentencias compuestas. Una sentencia compuesta es un conjunto de declaraciones y de sentencias agrupadas dentro de llaves {...}. También se conocen con el nombre de bloques. Una sentencia compuesta puede incluir otras sentencias, simples y compuestas. Un ejemplo de sentencia compuesta es el siguiente:

{ int i = 1, j = 3, k; double masa; masa = 3.0; k = y + j; }

Las sentencias compuestas se utilizarán con mucha frecuencia en las estructuras de control de flujo.

9.6. Tablas-resumen.

OPERADORES ARITMÉTICOS
Operador	Operación	Ejemplo
-	Resta o cambio de signo	cosa=3-valor;
+	Suma	printf(“%d”,4+6);
*	Producto	valor=2*PI*r;
/	División	test=5/9;
%	Módulo (Resto) de una división de enteros	resto=divdo%divsor;

OPERADORES DE ASIGNACIÓN E INCREMENTO
Operador	Operación	Ejemplo
=	Asignación (¡No igual!)	Y=10;x=2*a;a=getchar()
--	Decrementar	Y=--x; Y=x--;
++	Incrementar	Y=++x; Y=x++;
+=	Suma y asignación	Y+=2; (Y=Y+2)
-=	Resta y asignación	Y-=b; (Y=Y-b)
*=	Producto y asignación	Y*=(7/c); (Y=Y*(7/c))
/=	División y asignación	Y/=4; (Y=Y/4)
En general:Variable operador=Expresión oprerador=[+, -, *, /, %, <<, >>, &, | y

OPERADORES RELACIONALES
Operador	Operación	Ejemplo
<	Es Menor	Resul=a<b;
>	Es Mayor	If(a>b) resul=b>c;
<=	Es Menor o igual	Resul=a<=b;
>=	Es Mayor o igual	If(c>=x) b=23;
==	Es Igual	while(b==c) {........}
!=	Es Distinto	If(a!=3){..............}

OPERADORES LÓGICOS
Operador	Operación	Ejemplo
&&	AND	resul=dato1&&dato2;
||	OR	resul=dato1||dato2;
!	NOT	resul=!dato;

OPERADORES DE MANEJO DE BITS. (SÓLO PARA ENTEROS)

Operador

Operación

Ejemplo

&

AND entre bits

C=a&b;

|

OR entre bits

B=c|a;

^

XOR entre bits

X=by;

~

Inversor bit a bit

B=~v

<<

Desplazamiento a la izquierda, por la derecha entran ceros

B<<4; Desplaza B cuatro bits

>>

Desplazamiento a la derecha, por la izquierda entran ceros o el bit de signo

A>>8; Desplaza A ocho bits

OTROS OPERADORES

Operador

Operación

Ejemplo

Sizeof()

Tamaño en Byts

A=sizeof(float);

,

Coma

for(a=0,b=1;a<10;a++,b--)

&

Dirección

punt=&b;

*

Indirección

B=*punt;

9.7. Ejemplos.

Cada expresión tiene su valor:

Expresión

Valor

-4+6

2

C=3+8

11 ; C también vale 11

5>3

1 (verdadero)

10<1

0 (falso)

6+(c=3+8)

17

2>5+1

0 (la suma tiene preferencia)

a=8>5+1

1 (el igual tiene preferencia)

a=(8>5)+1

2

a=(8>5)+(b=1<3)

2

Para no tener problemas con las preferencias, es mejor colocar paréntesis.

/* cuadrados.c -- produce una tabla de 20 cuadrados */

#include <stdio.h>

int main(void)

{

int num = 1;

while (num < 21)

{

printf("%10d %10d\n", num, num*num);

num++;

}

return 0;

}

Podemos hacer el bucle más C:

while(num<21) printf("%10d %10d\n",

num++, num*num);

O podemos hacerlo más obstruso:

while(printf("%10d %10d\n", num++,

num*num)&&num<21);

En el primer caso se utiliza el postincremento dentro de los argumentos de printf(), es decir, se incrementa num después de imprimirlo (num++).

En el segundo caso se realiza toda la función en una única línea, aprovechando que printf) devuelve el número de caracteres escritos en esa llamada. El bucle se realizará mientras se imprima correctamente y num sea menor que 21.

/* botellas.c -- cuenta atrás */

#include <stdio.h>

#define MAX 100

int main(void)

{

int cont = MAX + 1;

while (--cont > 0)

{

printf("¡%d botellas de vino en el estante, %d botellas!\n",

cont, cont);

printf("Alguien pasó por delante y ¿qué fue de ellas?\n");

if (cont!=1)printf("¡Sólo quedan %d botellas!\n\n", cont - 1);

else printf("El vino se terminó.");

}

return 0;

}

9.8. Ejercicios:

a) Suponiendo que todas las variables son de tipo int. Indicar el valor de cada una de las siguientes expresiones:

Expresión,Valor

(2+3)*6

a=(22>5*5)

(12+6)/2*3

22==(a=(22<5*5)+21)

(2+3)/4

2==1+(a=3>1==(b=1))

3+2*(x=7/2)

4==(5*2+5>8)+3)

b) Sospecho que hay varios errores en el siguiente programa. ¿Podrías localizarlos?

/*ejer9-b.c*/

#include <stdio.h>

int main(void)

{

int i=1;

float n;

printf("¡Ojo, que va una ristra”);

printf(“ de fracciones\n");

while (i<30)

n=1/i;

printf(" %f",n);

printf("Esto es todo, amigos");

return 0;

}

c) Si los siguientes fragmentos formasen parte de un programa completo ¿Qué imprimirían?.

int x=0;

while(++x<3)

printf(“%d”,x);

int x=100;

while(x++<103)

printf(“%d\n”,x);

printf(“%d\n”,x);

char ch=’s’;

while(ch<’w’)

{

printf(“%c”,ch);

ch++;

}

printf(“%c\n”,ch);

d) Diseña un programa que realice lo siguiente:

Incremente en 10 la variable x.

Incremente en 1 la variable x.

Asigne a c el doble de la suma de a y b.

Asigne a c el valor de a más el doble de b.

Hay que procurar utilizar los operadores más adecuados a las operaciones a realizar.

e) Usando un bucle while, convierte valores en minutos, introducidos por teclado, en otros expresados en horas y minutos.

f) Realizar un programa que solicite un número entero y a continuación imprima todos los enteros comprendidos entre este valor y otro superior en 10 unidades, ambos inclusive.

g) Diseñar un programa que sume el cuadrado de los números comprendidos entre 1 y un número introducido por teclado.

h) Modificar el programa anterior para que una vez finalizado, solicite una nueva cantidad para repetir el proceso. Se interrumpirá cuando se introduzca una letra. Preparar una salida honrosa cuando se introduzca un 0.