TEMA 5: Expresiones y Sentencias

5.1	Expresiones

• Son el método fundamental que tiene el programador de expresar computaciones.

• Las expresiones están compuestas de operadores, operandos, paréntesis y llamadas a funciones. Los operadores pueden ser:

• Unarios: Cuando tan solo tienen un operando. Son operadores prefijos.

• Binarios: 2 Operandos. Son operadores infijos.

• Ternarios: 3 operandos.

• Operadores posfijos en C : a++

5.1.1 Orden de la evaluación de los operadores.

• El orden en que se evalúan los operandos viene dado por unas reglas:

• Reglas de procedencia

• Reglas de asociatividad

• Uso de paréntesis

• Precedencia

• El orden de evaluación de una expresión puede depender del orden de evaluación de los operadores: a+b *c

• Las reglas de evaluación de los operadores reciben una jerarquía. Esta jerarquía suele ser:

• Exponenciación

• Producto / División

• Suma / Resta

• Esto coincide en la mayoría de los lenguajes de programación porque viene de la jerarquía de operadores usada en la matemática. Muchos lenguajes de programación permiten el uso del + y del - además de cómo operadores binarios como operadores unarios. El + se usaría como operador de identidad y el - provocaría un cambio de signo.

• Asociatividad

• Las reglas de asociatividad definen el orden en que deben evaluarse operandos de igual precedencia que aparezcan de manera consecutiva en una expresión: a + b - c -c + h.

• Puede ser de 2 tipos:

• Asociatividad por la izquierda: Se evaluan los operadores de izquierda a derecha.

• Asociatividad por la derecha: Se evalúan los operadores de derecha a izquierda.

• La mayoría de los lenguajes de programación implementan una asociatividad de izquierda en la mayoría de sus operadores. Al operador de exponenciación se le suele aplicar asociatividad por la derecha: a ** b ** c

• Paréntesis

• Los paréntesis alteran las reglas anteriores (de precedencia y asociatividad). Se evalúa el primer lugar la subexpresión que aparece entre paréntesis.

5.1.2 Efectos laterales

• Si se producen efectos laterales podemos encontrarnos con esta situación: F(a)+f(a) <> 2 * f(a)

• Se provoca un efecto lateral en una función si cambia el valor de uno de sus parámetros o de una variable global. A + f(a) si f contiene un efecto lateral sobre la variable variará el valor de la expresión si calculamos 1º f(a) y luego sumamos a que si se coge a y le suma f(a).

Ej: C

Int a=5;

Int f1()

{

a=17;

return 3;

}

void f2()

{

a=a+f(1);

}

void main()

{

f2();

}

Si evaluamos los operandos de izquierda a derecha a = a + f1() = 5 + 3 = 8

Si evaluamos los operandos de derecha a izquierda a = a + f1() = 17 + 3 = 20

Una posible Solución: Fijar el orden de evaluación. Problema: Algunas técnicas que emplean los compiladores en la optimización del código necesitan que se altere el orden de los operandos con lo que perdemos el orden de evaluación.

Pascal y Ada no fijan el orden de evaluación de los operandos. Además, como se permiten efectos laterales, el mismo programa compilado por dos compiladores diferentes puede dar diferente resultado.

C sin embargo exige el orden de evaluación de los operandos de izquierda a derecha.

5.1.3 Expresión condicional

• Hay lenguajes que incluyen formas de expresiones muy diferentes como por ejemplo la expresión condicional:

ADA:

Q:=if x /= 0 then 1/x else 0

C incorpora un operador ternario:

Q= x!=0 ? 1/x : 0

5.1.4 Sobrecarga de operadores

• En muchos lenguajes el operador + se usa para sumar enteros, sumar números reales, concatenar strings etc. Se dice entonces que el operador + está sobrecargado (se realiza un uso múltiple).

• Ada permite definir al usuario operadores sobrecargados (C++ también)

Ej:

Producto escalar Escalar * vector de enteros

Definiríamos una función que hiciera el producto escalar y le daríamos como nombre el símbolo *.

¿Cómo decide el compilador que instrucción o función hay que usar?, Porque para las líneas de código “3.5 + 2.7” y “3 + 2” debemos emplear instrucciones máquina diferentes. Pues el compilador ve el tipo de los operadores que acompañan al operando.

• El hecho de que un lenguaje permita definir operadores sobrecargados aumenta la legibilidad del programa por lo que esta característica resulta muy útil. Si A, B, C y D son matrices, en caso de que se permita sobrecargar operadores haríamos A * B + C * D. Si no se permitiera deberíamos usar una sentencia de código muy parecida a la siguiente: “SumaMat(MultMatriz(A, B), MultMatriz(C, D))”

5.1.5 Conversión de tipos

• Las conversiones de tipo que podemos realizar pueden ser:

• Por ampliación: El tipo destino puede incluir una aproximación o al menos una aproximación para todos los valores del tipo original. C:int float 3 3.0

• Por reducción: El tipo destino no puede incluir todos los valores del tipo original. Ejemplo: C: double Float Se hace un redondeo

• Las conversiones pueden realizarse de manera implícita (coacción) ó de manera explícita.

• Coacción

• La coacción consiste en tener por ejemplo el siguiente caso: 2 + 3.5; A esta expresión se le llama “expresión en modo mixto”. En este caso el compilador debe iniciar la conversión en uno de los dos operandos. Los lenguajes de programación que permitan expresiones en modo mixto tendrán que definir algunas conversiones para estas conversiones implícitas. Es el propio compilador el que genera el código necesario para esta conversión. C realiza coacciones de una manera muy amplia. Provoca que el que se pierdan los beneficios de la conversión de tipos.

Ej: En C:

void main()

{

int a,b,c;

float d;

....

a=b*d;

{b se convierte en float, pero a sigue siendo int}

}

En este programa coacciona b con float; Producto de reales; Coacciona el resultado del producto a int (truncamiento). C no detecta este tipo de errores. Sin embargo Pascal detectaría esto como un error de tipos.

• Conversión exlícita de tipos

• La conversión explícita de tipos esta permitida por la mayoría de los lenguajes. Por ejemplo:

• ADA La conversión se realiza como si se llamara a una función.

Float (A) //Donde a es lógicamente una variable.

• C: se hace un cast que es como se designa la conversión explícita de tipos en C. Se suele conocer también como molde. (float)a //donde a es una variable

5.1.6 Expresiones relacionales y booleanas

• En una expresión relacional intervienen 2 operandos y un operador relaccional. (<,>,>=, ...)

• El valor de la expresión relaccional es de tipo booleano (en C es un valor entero). Se trata de expresiones que contienen operadores sobrecargados que permiten comparar caracteres, números de cualquier tipo ...

• Las expresiones booleanas incluyen:

• Variables booleanas

• Constantes Booleanas

• Expresiones relaccionales

• Operadores booleanos (y - and // o - or // no - not // o exclusivo - xor)

• Las expresiones booleanas devuelven un valor booleano.

• El orden de precedencia de los operadores booleanos es el siguiente: Not -> And->Or, Xot

• C no incluye el tipo booleano por eso representa este tipo con enteros en los cuales si el entero es 0 se supone que es falso y en caso contrario que es verdadero, o lo que es lo mismo:

• Se devuelve un valor distinto de 0 si el valor de la expresión booleana es cierto

• Se devuelve 0 si el valor de la expresión booleana es falso.

¡¡¡¡¡¡¡¡Ojo!!!!!!!!

• Relacionado con las expresiones booleanas es el hecho de que a veces no se necesita evaluar todos los operandos para conocer el resultado de una expresión.

A[1..10]

If (i<=10) and (a[i]>0) then

En este caso no sería necesario evaluar si a[i]>0 si se supiera que i es mayor que 10

Si durante la evaluación de una expresión no se necesita seguir evaluando los otros operandos se dice que es “evaluación perezosa”. Es altamente usada en lenguajes funcionales. En lenguajes de programación imperativos solo expresiones con OR y AND son evaluadas así. A estos operadores se les denomina operadores de circuito corto.

(A los operadores que se les hace una evaluación perezosa se les denomina operadores de circuito corto)

Los operadores de circuito corto unto con los efectos laterales pueden provocar situaciones poco deseables.

Ejemplo en C:

(a > b) || (b++ / 3)

Esta expresión contiene un efecto lateral que solo se evaluará en caso de que no se cumpla la primera condición “a > b”.

¿Qué hacen los lenguajes de programación al respecto?

C permite evaluación de circuito corto con los operadores booleanos.

Pascal no permite evaluación de circuito corto. No se pueden usar sentencias del siguiente tipo:

A:array[1..10] of integer;

If (i<=10) and (a[i]>0) then

Porque se accede a una posición no válida de un array.

Ada: “and”, “or” no son operaciones de circuito corto y “or them” y “and them” si son operaciones de circuito corto.

If (i<=10) and them (a[i]>0) them

5.2	Sentencia de Asignación

• Tienen un papel predominante en los lenguajes imperativos. Por eso los lenguajes de programación introducen el concepto de variable como que cambia en el tiempo. En cambio en los funcionales son parámetros de una función ( En C se hace referencia a una dirección mientras que en Haskell es una vbble matemática).

• La secuencia de asignación es un mecanismo que permite al usuario cambiar de manera dinámica la forma de vinculación de valores a variables. Forma general: LE:=RE (<Expresion izquierda>:=<expresion derecha>)

• La evaluación de la LE da como resultado una referencia y la evaluación de la RE da como resultado un valor. Por tanto podemos entender la secuencia de asignación como una operación sobre el par (referencia, valor)

• Variantes

• Se basa simplemente en la observación <destino><operador><otro operando>.

Ej:

i:=i+1;

a[n * k +j +1] := a [n * k + j + 1] *2;

Para simplificar las sentencias de este tipo algunos lenguajes de programación incluyen los operadores de asignación combinados. Por ejemplo en C += -= *= /=. Por lo que el ejemplo anterior quedaría:

a[n * k +j +1]*= 2;

Estos operadores hacen más fácil la tarea al programador y permiten que se genere código de una manera muy eficiente sin necesidad de aplicar técnicas de optimización.

• C incluye también operadores de asignación unarios que permiten incrementar o decrementar el valor de un operando. Estos operadores tienen valor diferente si se escriben de una manera prefija (en la que se habla de preincremento) o postfija (en la que se habla de postincremento).

Ej:

A=1

B=++a

//b=2 y a=2

a=1

b=a++;

//a=2 y b=1

5.2.2 Asignación de destinos múltiples

• Hay lenguajes de programación que permiten indicar más de una expresión izquierda o LE en una sentencia de asignación con una sintaxis de la forma: L1,L2.L3,L4 .. Ln := E; Se evalúa la expresión y se asigna el mismo valor a las n localizaciones.

• C permite asignación de destinos múltiples.A=b

En C las asignaciones se evalúan como expresiones. (dando como resultado un valor); Se puede hacer:

a=b=c=d=expresión (En realidad el igual no es operador de destino múltiple)

while((c=getchar())!=EOF)

5.2.3 Asignación simultanea

• Se transfiere simultáneamente más de un valor:

L1, L2 , ... , Ln:= E1 , E2, ... , En

Para realizar una asignación simltánea hay que:

Evaluar los valores de las L expresiones

Evaluar los Rvalores de cada Ei

Se realiza la asignación

Ej:

x,y:=y,x (Se intercambian los valores de x y de y -utiliza dirección de memoria ausiliar-)

• Errores samánticos; Podemos llegar a la siguiente situación:

A[i], a[j] : =3,5

Habría que plantearse cuál tendría que ser el resultado de la asignación si i=j

5.2.4 Asignación de modo mixto

• Se produce cuando tenemos un valor de un tipo y la regerencia de otro: LE:=RE

• Pascal: coacciones por ampliación

A:=3

{Donde a es una variable real y 3 es una constante entera Se puede hacer}

A:=8.75;

{Donde a es variable entera y 8.75 una constante real no se puede hacer o de lo contrario obtendremos un error de tipo}

A:=Trunc(8.75); A:=Round(8.75);

• C:

Por ampliación

Por reducción

A:=8.75; //Si A es una variable entera y 8.75 una constante real asignaría a A 8, es decir, realiza un truncamiento.

5.3	Controlde Flujo

• Dos mecanismos lingüísticos adicionales:

• Medio de selección: Poder seleccionar entre 2 o varios caminos de flujo alternativo

• Medio de ejecución repetida: de una colección de sentencias

• Al conjunto de sentencia que proporcionan ambos medios se denominan sentencias de control. El conjunto idóneo de sentencias de control depende de los objetivos de los diseñadores del lenguaje. Si el diseñador quiere diseñar un lenguaje pequeño y simple entonces tendremos un conjunto reducido de sentencias de control.

• Estructura de control: Hace referencia a la sentencia de control y al conjunto de sentencias cuya ejecución controla la primera.

5.3.1 Composición de sentencias

• Secuenciador: Indica que sentencia debe ser la próxima en ejecutarse.

Ejemplo: Secuenciador

i:=i+1 ; j:=j+1

• Si el lenguaje no dispone de un Secuenciador explícito se mantiene el orden de escritura.

• Otro Secuenciador: Sentencia GOTO: Lo que hace es especificar una etiqueta que indica la siguiente computación. El control de flujo se transfiere s la sentencia que lleva el GOTO.

• Hay lenguajes que permiten agrupar conjuntos de sentencias considerándolas como una sola (sentencia compuesta).

Ejemplo:

Begin

S1;

S2; Sentencia compuesta

.....

Sn;

End

• Si la sentencia compuesta permite siempre añadir declaraciones al comienzo, se habla de “bloque”.

Ejemplo:

5.3.2 Selección

• Una sentencia de selección proporciona el medio de elección entre 2 o mas caminos de ejecución.La selección aparece en todos los lenguajes imperativos.

• La forma mas simple de selección es la sentencia IF.

• Se puede realizar una selección entre un numero de segmentos de código basándose en el valor de una variable entera o de una variable enumerada. Sentencia case:

• Se evalúa la expresión y el valor resultante se busca en el conjunto de la lista de valores y se ejecuta la sentencia asociada a ese valor. Al final se devolvería el control a la siguiente sentencia que vaya después del End.

• ¿Qué ocurre si el valor resultante de la expresión no aparece en ninguna de las listas de valores?

• En pascal: El resultado es indefinido. Dependiendo del implementador del compilador se hace una cosa y otra;

• no se hace nada

• dar un error en tiempo de ejecución

• Lo que se suele hacer es incluir la cláusula otherwise/else que no esta definida en el Pascal estándar (se ejecutaría la sentencia asociada).

• En c: Si el valor no aparece en la lista, no se hace nada.C incluye una cláusula: default equivalente al otherwise de Pascal

• En Ada: en tiempo de compilación se comprueba que aparecen en la lista de calores todos los valores posibles de la expresión. La cláusula others para que no haga nada ( por ejemplo)

• Aparecen otros problemas referentes a la utilización de la sentencia caso:

• Restricciones Habituales:

• Las expresiones que forman parte de las listas de valores debe ser posibles esamblarlas en tiempo de compilación.

• No se suele permitir que aparezca duplicado un valor en las listas de valores.

En C: Solo se permite que aparezca un valor en cada lista de variables. De manera que para el usuario pueda definir una misma acción para distintos casos (valores): hay que utilizar de una manera explícita una transferencia de control: Break;

5.3.3 Repetición

• Tenemos sentencias iterativas o repetitivas, que son aquellas que provocan que una sentencia o colección de sentencias seas ejecutadas 0,1 o mas veces

• En los lenguajes funcionales la repetición se hace muy distinta a la de los lenguajes imperativos (se hace con recursividad);

• En los lenguajes imperativos: 2 formas de repetición:

La repetición se realiza sobre un conjunto precalculado (finito) Sentencia For

La repetición esta basada en la evaluación de una condición Sentencia While

Bucles controlados por contador.

• Permiten la repetición de una sentencia o un conjunto de sentencias un numero determinado de veces ( a priori). ara ello utilizan una variable de control que cuenta el numero de veces que se llevan hasta ese momento. Esta variable de control esta a disposición de las sentencias que se repiten (saben en que iteración esta).

• Es muy útil para el recorrido de arrays (se conoce a priori el recorrido del array).

• Pascal:

For variable:=valor_inicial to valor_final do

Sentencia;

• Ada:

For variable in [reverse] rango_discreto Loop

...

End Loop

El rango discreto va de 1 a n

El reverse es opcional y equivale al downto de Pascal

• Hay lenguajes que incluyen sintaxis para que el programador pueda indicar el tamaño del incremento.

Ej: 1 to 10 by 2 -> 1,3,5,7,9

• ¿Qué sucede con la sentencia for de C ?

for ([exp1]; [exp2];[exp3])

sentencia;

donde:

exp1: expresion de inicializacion,se evalua una sola vez al comienzo del bucle.

exp2: expresion de control de bucle (se evalua al comienzo de cada ejecucion del cuerpo del bucle).

exp3: se ejecuta siempre despues de ejecutar la ultima expresion del cuerpo del bucle.

(Es como una sentencia while disfrazada).

Si hacemos :

For (; exp ;)

Sentencia;

Equivale a:

While (exp)

Sentencia;

• Cuestiones relacionadas con la sentencia for.

¿Quién declara la variable de control y cual es el ambito de esa variable?

• PASCAL,C: La variable de control la declara de manera explicita el programador.La declarará en el bloque donde está la sentencia for o en algun bloque anterior. El ámbito de la variable de control será el ambito del bloque.

• ADA: La variable de control del bucle se declara de manera implicita. El ámbito de esa variable se restringe al cuerpo del bucle. Decide cual es el tipo de la variable a partir de la evaluacion del rango.

¿Cuál es el valor de la variable de control una vez finalizado el bucle?

• PASCAL ESTÁNDAR: el valor es indefinido (depende de la implementacion del compilador)

• C: el valor será el valor que ha hecho falso la evaluacion de la expresion.

• ADA: no se puede hacer referencia al valor de esa variable.

¿Puede modificarse el valor de la variable de control desde el interior del bucle?

• PASCAL,ADA:No

• C: Si

¿Puede modificarse el rango sobre el que se mueve la variable de control desde el interior del bucle?

• C: Sí ,porque la evaluacion de la exp2 se produce en cada iteracción.

• PASCAL,ADA: Si, lo que ocurre es que el rango se evalua 1 sola vez antes del comienzo de la 1ª iteraccion. Se permite modificar pero esto no va a afectar al control del bucle.

• Bucles controlados de manera lógica.

• Permiten ejecutar una colección de sentencias de manera que el control se realiza mediante la evaluacion de una expresion booleana.

• Muchos lenguajes de programacion imperativa incluyen 2 tipos de bucle:

Ej:

• PASCAL:

While expr do

Begin

Sentencia;

End

Se ejecutará mientras la evaluacion de la condicion sea cierta.

Repeat

Sentencia;

Until expr;

No es ortogonal porque si hay varias sentencias no hace falta poner Begin y End.

Siempre se ejecuta como minimo 1 vez .Se sale cunado el valor de la expresion es cierta.

• C:

While (expr)

{

Sentencia;

}

do

{

Sentencia;

}

while (expr)

• El lenguaje C si que es ortogonal porque utiliza en los dos casos las { } para el conjunto de sentencias.

Nota: Forma diferente de sentencias de control que son deterministas.

5.3.4 SELECCIÓN E ITERACCION NO DETERMINISTA

• Dijkstra (1975) sugirió una alternativa a las sentencias de selección y bucle que hemos visto. La selección propuesta por Dijkstra es :

If <expresion booleana 1> -> <sentencia 1>

[ ] <expresion booleana 2> -> <sentencia 2>

[ ] <expresion booleana 3> -> <sentencia 3>

[ ] ...

[ ] <expresion booleana N> -> <sentencia N>

fi

• Siempre se avaluan todas las expresiones booleanas de forma que si es cierta mas de una expresion,se elige ejecutar alguna de las sentencias asociadas.

• Si ninguna de las sentencias es cierta se produce un error en tiempo de ejcución.

• Si la evaluacion tiene una sola sentencia cierta solo se ejecutará esa.

• Propone una solucion elegante cuando se puede llegar a una misma solucion por caminos diferentes.

Ej:

If x>=y -> max:=x

[ ] y>= -> max:=x

fi

x=y sea cual sea la que se ejecuta el resultado va a ser el mismo.

• Propone ademas una estructura de bucle de caracteristicas similares:

Do <expresion booleana 1> -> <sentencia 1>

[ ] <expresion booleana 2> -> <sentencia 2>

[ ] <expresion booleana 3> -> <sentencia 3>

[ ] ...

[ ] <expresion booleana N> -> <sentencia N>

od

• Todas las expresiones booleanas se evaluan en cada iteraccion del bucle,si son ciertas maas de una expresion se elije ejecutar de forma aleatoria de una de ellas. El bucle finaliza cunado la evaluacion de todas las expresiones da como resultado falso.

Ej:

Q1,q2,q3,q4 =>q1<= q2<= q3<= q4

Ordena el contenido de las variables

Do q1<q2 -> temp:=q1;q1:=q2;q2:=temp;

[ ] q2<q3 -> temp:=q2;q2:=q3;q3:=temp;

[ ] q3<q4 -> temp:=q3;q3:=q4;q4:=temp;

od

• Estas sentencias están implementadas en lenguajes de tipo concurrente.

5.4	Control Global

• Varios tipos de estructuras de control no local (El control no hace referencia a un conjunto de sentencias dentro de un while o un if sino que son de tipo_____ ).

5.4.1 SENTENCIA GOTO

• Es una instrucción bastante antigua,sencilla y muy eficiente.

• Es la sentencia de bifurcacion incondicional y aparece en todos los lenguajes maquina.

• En los lenguajes de alto nivel su uso era considerado:

• Básico: porque estaba entodos los lenguajes máquina.

• Necesario: porque no incluian ninguna estructura de control con tanta flexibilidad.

• Ademas esos primeros lenguajes no incluian el concepto de ámbito.

• A finales de los 60 y comienzos de los 70 surgió la polémica sobre si se debía utilizar la sentencia goto,puesto que el uso de la sentencia goto de manera indiscriminada hacia los programas ilegibles,poco fiables y dificiles de mantener.

• Todos estos problemas lleban a dos situaciones:

• Modula-2 no incluye la sentencia goto.

• Se limita el posible uso de esa sentencia.

Ej:

Pascal restringe el uso de la sentencia goto:

• las etiquetas se declaran.

• las etiquetas no se pasan como parametro.

• las etiquetas no se modifican.

• las etiquetas no se almacenan.

• la etiqueta que acompaña al goto debe ser una constante.

• ¿a dónde podemos saltar con un goto?

Si el goto está dentro de una sentencia de control.

While

Begin

...

...

Goto

End

Si el destino es una sentencia de algún grupo que contiene la secuencia de sentencias donde se incluye el goto.

Begin

...

1

...

While

Begin

...

Goto

...

End

...

2

...

End

• Se podría hacer un goto 1 o goto 2.

While

Begin

...

1

...

End

While

Begin

...

Goto

...

End

• No se podría hacer un goto 1

El objetivo tambien puede ser una secuencia de otro subprograma incluido en el ámbito del que tiene el goto.

Ej:

Procedure sub1

Label 100

...

Procedure sub2

...

goto 1000

...

End

...

100

End

• Sin embargo,si esta sentencia estubiera dentro de un while,sería incorrecto porque la sentencia destino no puede estar dentro de un conjunto de sentencias.

5.4.2 MECANISMOS DE CONTROL DE BUCLE

• Bucle while:

Proporciona un punto de comprobación al comienzo del bucle.

• Bucle Repeat-Until:

El punto de comprobación está al final del bucle.

• El elemento de comprobación se puede poner en cualquier punto del cuerpo del bucle,pero estas sentencias destruyen la semantica de estas instrucciones.

• Estas sentencias como break o exit,permiten incluso salir de varios bucles anidados.

En C:

Break y continue (transfiere el control a la sentencia de comprobación del bucle).

Ej:

While ( suma < 100)

{

get(valor);

if (valor<0) continue ó break;

suma+=valor;

}

• Si utilizamos continue volvemos a evaluar la condicion del bucle y si usamos break salimos del bucle.

Tema 5: Expresiones y sentencias LPR

1

15

While ()

{

int i,j;

}

Bloque (en C y Ada)

While condición do

Begin

End

Sentencia compuesta

Ada:

If x<0 then

Y:=-x;

Else

Y:=x;

Endif;

Facilita la asociación de los else o las cláusulas then

C:

If (x<0)

Y =-x;

[else

y=x;]

En c se asocia el else al ultimo if que no tiene else

Ada:

If suma=0 then

If contador=0

resultado:=0

Else

resultado:=1

endif

indif

Pascal:

If suma=0 then

Resultado:=0

Else (asociado al ultimo if)

Resultado:=1;

Pascal

Case expresión of

Lista_constantes_1: Sentencia 1;

..........................................

Lista_constantes_n: Sentencia n;

End;

Switch (índice)

{

Case 1: i=x;

Case 3: impar+=1;

Suma_impar+=indice;

Break;

Case 4: .

.

.

.

Switch (índice)

{

Case 1:

Case 3: impar+=1;

Suma_impar+=indice;

Break;

Case 2:

Case 4: par+=1;

Suma_par+=indice;

Break;

Default sentencia