Aula 6 Instruções de selecção e instruções condicionais.

Aula 6

Instruções de selecção e instruções condicionais

2003/2004Introdução à Programação2

Instrução de selecção

if(G) instrução1;else instrução2; instrução1 instrução2

[G] [¬G]

Início da actividade

Fim da actividade

Guarda

Actividade

Transição

Entroncamento

Ramificação


Instrução de selecção: Exemplo

int x;cin >> x;

if(x < 0) x = 0; else x = 1;

cout << x << endl;131

x: int

1

x: int

?

x: int

13


Instrução condicional

if(G) instrução1;

instrução1

[G]

[¬G]


Instrução condicional: Exemplo

int x;cin >> x;

if(x < 0) x = 0;

cout << x << endl;1313

x: int

13

x: int

?


Instrução condicional

if(G) instrução1;

é o mesmo que

if(G) instrução1;else ; // Instrução nula

instrução1

[G]

[¬G]


Porquê ser disciplinado?

Para não errar? Problema simples na Aula prática Aposto:

Vão esquecer a disciplina Vão errar 1ª versão Vão errar 2ª versão Talvez acertem à terceira…


absolutoDe()

/** Devolve o valor absoluto do argumento.

@pre ?.

@post ?. */

int absolutoDe(int const valor){ ... }

O que faz

Como funciona

Como se usa


absolutoDe(): pré-condição


@pre V.

@post ?. */

int absolutoDe(int const valor){ ... }


absolutoDe():condição-objectivo


@pre V.

@post 0 ≤ absolutoDe. */

int absolutoDe(int const valor) { ... }

É suficiente? Não há relação entre o valor devolvido e valor!




@pre V.

@post 0 ≤ absolutoDe. */

int absolutoDe(int const valor) { return 5;}

Errado! Mas, ... A condição objectivo verifica-se!




@pre V.

@post 0 ≤ absolutoDe e (absolutoDe = valor ou

absolutoDe = -valor). */

int absolutoDe(int const valor){ ...

}


absolutoDe()

/** Devolve o valor absoluto do argumento. @pre V. @post 0 ≤ absolutoDe e (absolutoDe = valor ou absolutoDe = -valor). */int absolutoDe(int const valor){ int absoluto;

...

return absoluto;}


absolutoDe()

/** Devolve o valor absoluto do argumento. @pre V. @post 0 ≤ absolutoDe e (absolutoDe = valor ou absolutoDe = -valor). */int absolutoDe(int const valor){ // V int absoluto;

...

// 0 ≤ absoluto e // (absoluto = valor ou absoluto = -valor) return absoluto;}

Asserções: afirmações acerca do estado do programa



absolutoDe()

/** Devolve o valor absoluto do argumento. @pre V. @post 0 ≤ absolutoDe e (absolutoDe = valor ou absolutoDe = -valor). */int absolutoDe(int const valor) { assert(true); // V int absoluto;

...

// 0 ≤ absoluto e // (absoluto = valor ou absoluto = -valor) assert(0 <= absoluto); assert(absoluto == valor or absoluto == -valor);

return absoluto;}


Instruções de asserção: Verificação explícita de asserções.


absolutoDe()

Instruções que resolvem o problema:

absoluto = valor;

absoluto = -valor;


Dedução de asserções (I)

double x, y;

...

y = x * x;

Em que circunstâncias se garante que, depois desta instrução, se tem 2 < y?


Dedução de asserções (II)

double x, y;

...

y = x * x;// 2 < y


Dedução de asserções (III)

double x, y;

...

// ?

y = x * x;// 2 < y


Dedução de asserções (IV)

double x, y;

...

// PC: ?

y = x * x;// CO: 2 < y


Dedução de asserções (IV)

double x, y;

...

// PC: 100 < xy = x * x;// CO: 2 < y

Demasiado forte!

Muito restritiva.

Conjunto de valores possíveis podia ser maior!


Asserções

Asserção A mais forte que asserção B: A mais restritiva que B Conjunto de valores verificando A contido em conjunto de

valores verificando B Asserções fortes correspondem a conjuntos pequenos

Asserção A mais fraca que asserção B: A menos restritiva que B Conjunto de valores verificando A contém conjunto de

valores verificando B Asserções fracas correspondem a conjuntos grandes


Partindo da condição objectivo...

1. Solução do problema é mais simples

2. Programação é actividade dirigida pelos objectivos


Dedução da PC mais fraca

Dada a instrução de atribuição

variável = expressão;// CO

Qual PC mais fraca possível? Na CO, substituir todas as ocorrências de variável por expressão


Dedução da PC mais fraca:exemplo 1

double x, y;

...

// PC: ?

y = x * x;// CO: 2 < y



double x, y;

...

// PC: 2 < x2, ou seja, x < -2½ ou 2½ < xy = x * x;// CO: 2 < y



// PC: ?++x;// CO: x ≤ 0

é equivalente a

// PC: ?x = x + 1;// CO: x ≤ 0



// PC: x + 1 ≤ 0, ou seja, x ≤ -1

x = x + 1;// CO: x ≤ 0



// PC: ?

x = x * x - 2; // CO: 0 ≤ x



// PC: 0 ≤ x2 - 2, ou seja, 2 ≤ x2, ou seja,

// PC: x ≤ -2½ ou 2½ ≤ xx = x * x - 2; // CO: 0 ≤ x


absolutoDe()

// PC1: ?absoluto = -valor;// 0 ≤ absoluto e// (absoluto = valor ou absoluto = -valor)

e

// PC2: ?absoluto = valor;// 0 ≤ absoluto e// (absoluto = valor ou absoluto = -valor)


absolutoDe(): PC1

// PC1: 0 ≤ -valor e

// (-valor = valor ou -valor = -valor), ou seja,

// PC1: valor ≤ 0 e (-valor = valor ou V), ou seja,

// PC1: valor ≤ 0 e V, ou seja,

// PC1: valor ≤ 0

absoluto = -valor;// 0 ≤ absoluto e

// (absoluto = valor ou absoluto = -valor)


absolutoDe(): PC2

// PC2: 0 ≤ valor e

// (valor = valor ou valor = -valor), ou seja,

// PC2: 0 ≤ valor e (V ou valor = -valor), ou seja,

// PC2: 0 ≤ valor e V, ou seja,

// PC2: 0 ≤ valor

absoluto = valor;// 0 ≤ absoluto e

// (absoluto = valor ou absoluto = -valor)


absolutoDe():instrução de selecção

if(valor <= 0) absoluto = -valor;else // 0 < valor absoluto = valor;

0 < valor implica 0 ≤ valor

// 0 < valor // 0 ≤ valor

Diferente de0 ≤ valor


Implicação

A implica B Conjunto de valores verificando A (A) está

contido no conjunto de valores que satisfaz B (B)

A é mais forte que B

// A

// B

A

B


absolutoDe()

/** Devolve o valor absoluto do argumento. @pre V. @post 0 ≤ absolutoDe e (absolutoDe = valor ou absolutoDe = -valor). */int absolutoDe(int const valor){ int absoluto;

if(valor <= 0) absoluto = -valor; else absoluto = valor;

assert(0 <= absoluto); assert(absoluto == valor or absoluto == -valor);

return absoluto;}


absolutoDe()

/** Devolve o valor absoluto do argumento. @pre V. @post 0 ≤ absolutoDe e (absolutoDe = valor ou absolutoDe = -valor). */int absolutoDe(int const valor) { int absoluto = valor <= 0 ? –valor : valor;

assert(0 <= absoluto); assert(absoluto == valor || absoluto == -valor);

return absoluto;}


absolutoDe()

/** Devolve o valor absoluto do argumento. @pre V. @post 0 ≤ absolutoDe e (absolutoDe = valor ou absolutoDe = -valor). */int absolutoDe(int const valor){ return valor <= 0 ? –valor : valor;}


valorMaisProximoDentroDe()

double valorMaisPróximoDentroDe(double const v, double const mín, double const máx){ double r;

...

return r;}



/** Devolve o valor de v limitado ao intervalo dado. @pre mín ≤ máx. @post (v < mín e valorMaisPróximoDentroDe = mín) ou (máx < v e valorMaisPróximoDentroDe = máx) ou (mín ≤ v e v ≤ máx e valorMaisPróximoDentroDe = v). */ double valorMaisPróximoDentroDe(double const v, double const mín, double const máx){ assert(mín <= máx); // PC: mín ≤ máx

double r; ... // CO: v < mín e r = mín ou máx < v e r = máx ou mín ≤ v e v ≤ máx e r = v assert(v < mín and r = mín or máx < v and r = máx or mín <= v and v <= máx and r = v);

return r;}



Instruções que resolvem o problema:

r = mín;

r = máx;

r = v;


r = mín;

// PC1: (v < mín e mín = mín) ou (máx < v e mín = máx) ou // (mín ≤ v e v ≤ máx e mín = v)r = mín; // (v < mín e r = mín) ou (máx < v e r = máx) ou // (mín ≤ v e v ≤ máx e r = v)

Pode-se simplificar esta pré-condição:

// PC1: (v < mín e V) ou (máx < v e mín = máx) ou// (v ≤ máx e mín = v)

// PC1: v < mín ou (máx < v e mín = máx) ou// (v ≤ máx e mín = v)

mín ≤ ve

min = v


r = máx;

// PC2: (v < mín e máx = mín) ou (máx < v e máx = máx) ou // (mín ≤ v e v ≤ máx e máx = v)r = máx; // (v < mín e r = mín) ou (máx < v e r = máx) ou // (mín ≤ v e v ≤ máx e r = v)

Pode-se simplificar a pré-condição para:

// PC2: (v < mín e máx = mín) ou (máx < v e V) ou// (mín ≤ v e máx = v)

// PC2: (v < mín e máx = mín) ou máx < v ou// (mín ≤ v e máx = v)

v ≤ máxe

máx = v


r = v;

// PC3: (v < mín e v = mín) ou (máx < v e v = máx) ou// (mín ≤ v e v ≤ máx e v = v)r = v;// (v < mín e r = mín) ou (máx < v e r = máx) ou // (mín ≤ v e v ≤ máx e r = v).

Pode-se simplificar esta pré-condição para:

// PC3: F ou F ou (mín ≤ v e v ≤ máx)

ou seja

// PC3: mín ≤ v e v ≤ máx


Instrução de selecção (I)

// PC: mín ≤ máxif(C1) // PC1: v < mín ou (máx < v e mín = máx) ou (v ≤ máx e mín = v) r = mín;else if(C2) // PC2: (v < mín e máx = mín) ou máx < v ou (mín ≤ v e máx = v) r = máx;else // PC3: mín ≤ v e v ≤ máx r = v;


Instrução de selecção (II)

Sabendo que min ≤ máx

// PC: mín ≤ máxif(C1) // PC1: v < mín ou (máx < v e mín = máx) ou (v ≤ máx e mín = v) // v < mín ou (máx < v e mín = máx) ou mín = v // v ≤ mín ou (máx < v e mín = máx) r = mín;else if(C2) // PC2: (v < mín e máx = mín) ou máx < v ou (mín ≤ v e máx = v) // (v < mín e máx = mín) ou máx < v ou máx = v // (v < mín e máx = mín) ou máx ≤ v r = máx;else // PC3: mín ≤ v e v ≤ máx r = v;


Instrução de selecção (III)

// PC: mín ≤ máxif(C1)

// PC1: v ≤ mín ou (máx < v e mín = máx) r = mín;else if(C2)

// PC2: (v < mín e máx = mín) ou máx ≤ v r = máx;else // PC3: mín ≤ v e v ≤ máx r = v;

Diferente de0 ≤ valor

Sobreposições!


Instrução de selecção (IV)

Eliminando as sobreposições

// PC: mín ≤ máxif(C1) // PC1: v ≤ mín r = mín;else if(C2) // PC2: máx ≤ v r = máx;else // PC3: mín ≤ v e v ≤ máx r = v;


Instrução de selecção (V)

Eliminando ainda mais algumas sobreposições

// PC: mín ≤ máxif(C1) // PC1: v < mín r = mín;else if(C2) // PC2: máx < v r = máx;else // PC3: mín ≤ v e v ≤ máx r = v;


Instrução de selecção (VI)

Escolhendo as condições

// PC: mín ≤ máxif(v < mín) // PC1: v < mín r = mín;else if(máx < v) // PC2: máx < v r = máx;else // PC3: mín ≤ v e v ≤ máx r = v;



/** ... */ double valorMaisPróximoDentroDe(double const v, double const mín, double const máx){ assert(mín <= máx);

double r;

if(v < min) r = mín; else if(máx < v) r = máx; else r = v;

assert(v < mín and r = mín or máx < v and r = máx or mín <= v and v <= máx and r = v);

return r;}




if(v < min) return mín; else if(máx < v) return máx; else return v;}




if(v < min) return mín; if(máx < v) return máx; return v;}


Metodologia de desenvolvimento de instruções de selecção Especificar bem problema: escrever PC e CO Ver bem CO: será necessária instrução de selecção?

Bom indício é existência de "ous" na CO Se for:

Ver CO e identificar n instruções (ou sequências de instruções) que permitam atingir CO

Determinar pré-condição mais fraca de cada instrução Guarda de cada instrução é condição mais fraca que,

dada a pré-condição global, garante verificação da sua pré-condição

Fundamental que guardas cubram todos os casos! Se não acontecer, voltar atrás e tentar encontrar mais instruções para casos em falta


Aula 6: Sumário

Instrução de selecção if else e instrução condicional if: Sintaxe Transformação entre tipos de instrução de selecção Exemplos

Asserções Conceitos Dedução de asserções: directa e inversa Caso da instrução de atribuição

Guardas de instruções de selecção Metodologia de desenvolvimento de instruções de selecção:

importância de partir dos objectivos Simplificação de instruções de selecção Operação ? : Importância do cálculo curto-circuitado dos operadores lógicos

Aula 6 Instruções de selecção e instruções condicionais.

Documents

Transcript of Aula 6 Instruções de selecção e instruções condicionais.