Uso do SWITCH/CASE

[spma...@aol.com]

Posso usar o CASE dessa forma ?

case 1 ;
{
printf ("CONSULTAR ALGUMAS CALORIAS\n");
printf("\n1-Salgado");
printf("\n2-Doces");
printf("\n3-Bebidas");
printf("\nEscolha uma das categorias que deseja consultar:");
scanf("%d",&escolha);
}

Agradeço quem responder.

Mateus

Convite para o Netlog :
http://pt.netlog.com/go/register/friend=mateuscps

[Pedro d'Aquino]

Não. Procurando no Google por [switch case C], vem http://www.eng.uerj.br/~marcelo/msx/cursos/c10.html:

switch (variável) 
{ 
  case valor1 : expressão; break; 
  case valor2 : expressão; break; 
  ... 
  default: expressão; 
}

ou seja, com ":" depois do case e um "break" no fim de cada case.

2008/11/13 <spma...@aol.com>

[Renne Rocha]

Não.... tá faltando o switch também.....

http://www.google.com.br/search?hl=pt-BR&client=firefox-a&rls=org.mozilla%3Apt-BR%3Aofficial&hs=kCG&q=switch+C%2B%2B&btnG=Pesquisar&meta=

Nos primeiros resultados você já tem a sintaxe correta...

Aqui tem alguma coisa que lembra o que parece que você quer fazer...
http://www.vivaolinux.com.br/scripts/verFonte.php?codigo=1363&arquivo=Switch.c

Por que você não pesquisa no Google antes?

Renne Rocha
renne...@gmail.com
+55 19 8139-8456



2008/11/13 <spma...@aol.com>:

[Felipe Ferreri Tonello]

Cara, recomendo um ótimo site de estudos de, principalmente, C++[1]. Lá tem referencia, exemplos, explica cada função, templates de STL, etc... é bem legal.

[1] http://www.cplusplus.com/

[Fabio A Mazzarino]

Mateus:


Considerando que vc está usando o case dentro de um switch, e que ao
invés de ; depois do case vc está usando :, vc pode usar sim.

Não há problema algum em abrir um escopo novo para o case. Mas tenha
em mente que as variáveis declaradas dentro do escopo do case serão
'destruidas' qdo acabar o escopo.

Portanto:

switch(opcao) {

case 1: {
printf ("CONSULTAR ALGUMAS CALORIAS\n");

break;
}
}

Compila sem problemas e não vai lhe causar problema algum, nem mm de estilo.

Note que esta construção é muito utilizada qdo dentro do case vc
precisa declarar diversas variáveis que não serão mais necessárias
fora do case, afora isso é uma construção inútil.

Note tb que o break não deixa de ser necessário.

Fabio

--
Doses Diárias - Achados de um Programador na Internet
http://dosesdiarias.seucaminho.com



2008/11/13 <spma...@aol.com>:

[Juliano F. Ravasi]

Fabio A Mazzarino wrote:
> Note que esta construção é muito utilizada qdo dentro do case vc
> precisa declarar diversas variáveis que não serão mais necessárias
> fora do case, afora isso é uma construção inútil.

Note que é também possível declarar variáveis dentro do 'switch', antes
do primeiro 'case'. Poucos sabem disso, e é útil para variáveis que são
comuns a todos os 'case's.

switch (test) {
int i, j;

case 0:
...
}

Só um grande porém: variáveis declaradas no bloco do switch não podem
ser inicializadas na declaração.

--
Juliano F. Ravasi ·· http://juliano.info/
5105 46CC B2B7 F0CD 5F47 E740 72CA 54F4 DF37 9E96

"A candle loses nothing by lighting another candle." -- Erin Majors

* NOTE: Don't try to reach me through this address, use "contact@" instead.

[Hélder Gomes]

Ta bom, ele não perguntou se pode usar switch dentro do for...

2008/11/13 Juliano F. Ravasi <m...@juliano.info>

[Eduardo Arruda]

Mas não seria bom usar o break?? Evitaria comparações?

2008/11/13 Hélder Gomes <orsp...@gmail.com>:

[P.]

On 13 nov, 13:12, "Fabio A Mazzarino" <fabio.mazzar...@gmail.com>
wrote:

>  Não há problema algum em abrir um escopo novo para o case. Mas tenha
> em mente que as variáveis declaradas dentro do escopo do case serão
> 'destruidas' qdo acabar o escopo.

Em outro email, um colega descreveu o "corpo" do case como uma
"expressão":

case LABEL: expressão; break;

Isto não é totalmente correto; o que segue um case neste caso é um
"statement".
A distinção é interessante nesse caso pelo seguinte: você pode abrir
um novo escopo -- um block-statement -- em qualquer lugar onde o
compilador espera um "statement".

O case neste caso é equivalente ao if; o que segue um if é um
statement; o tipo mais comum de statement que usamos após if é o block-
statement.

--
P.

[Fabio A Mazzarino]

Eduardo:

O break é necessário para evitar que o case seguinte seja executado.

Amba as construções abaixo estão corretas:

a = 1;
switch(a) {
case 1: {
printf("Um\n");
break;
}
case 2: {
printf("Dois\n");
break;
}
}

b = 1;
switch(b) {
case 1: {
printf("Uno\n");
}
case 2: {
printf("Duo\n");
}
}

Na primeira construção será exibido:
Um

Enquanto que na segunda construção:
Uno
Duo

Ou seja, o break não deixou de ser necessário para evitar erros de lógica.

Fabio

Doses Diárias - Achados de um Programador na Internet
http://dosesdiarias.seucaminho.com

2008/11/13 Eduardo Arruda <duduz...@gmail.com>:

[Vanessa Leite]

Isso acontece mesmo?

Nao parece me fazer muito sentido. Afinal, se a variavel b possui valor 1, pq entrar no case 2?

Penso que o break serve pra uma otimização ou algo assim, pra nao fazer iterações desnecessarias. Nao seria isso?

2008/11/14 Fabio A Mazzarino <fabio.m...@gmail.com>

--
Vanessa Leite
---
Ciência da Computação
Universidade Federal do Maranhão - UFMA
'DiOTT - Debug is On The Table'
(Maratona de Programação)

[Pedro d'Aquino]

Vanessa, isso acontece sim. Esse comportamento se chama "fall through" e é na maior parte das vezes um bug, mas há situações em que é desejado.

Não sei por que é desse modo, entretanto. Não acho que seja necessidade do compilador, porque acho que ele poderia facilmente reconhecer o fim de um statement sem o "break". Alguém deve ter achado que esse comportamento era útil...

Em C#, aliás, o fall through não é permitido:

switch (i)

{

   case 1:

       Console.WriteLine("1");

   default:

       Console.WriteLine("default");

}

error CS0163: Control cannot fall through from one case label ('case 1:') to another

error CS0163: Control cannot fall through from one case label ('default:') to another

2008/11/14 Vanessa Leite <vanessinhal...@gmail.com>

[Renne Rocha]

Esse comportamento é util sim... evita muita duplicação de código em
condicionais com vários operadores OR... dou manutenção em alguns
sistemas que sem essa construção virariam um monstro de IFs para dar
manutenção...

Exemplo:
if( a ==1 || a == 2 || a ==3 ) {
dosomething();
} elseif(a==4) {
domore();
} else {
donothing();
}

Substituindo para switch/case (muito melhor para manutenção futura!!!)

switch (a) {
case 1:
case 2:
case 3:
dosomething();
break;

case 4:
domore();
break;

default:
donothing();
break;

}


Renne Rocha
renne...@gmail.com
+55 19 8139-8456

2008/11/14 Pedro d'Aquino <bud...@gmail.com>:

[Juliano F. Ravasi]

Renne Rocha wrote:
> Esse comportamento é util sim... evita muita duplicação de código em
> condicionais com vários operadores OR... dou manutenção em alguns
> sistemas que sem essa construção virariam um monstro de IFs para dar
> manutenção...

Outro bom exemplo é o "Dispositivo de Duff", uma forma de otimização de
laços: http://en.wikipedia.org/wiki/Duff's_device

O 'switch' tem esse aspecto porque ele é basicamente uma forma de
'goto'. Os 'case's e o 'default' são representados como rótulos
(terminados em ":"), e devem ser considerados como tal, ou seja, a
execução passa através do rótulo. O 'switch' é um 'goto' controlado pelo
valor da expressão fornecida, que pula a execução para um determinado
rótulo, e continua dali para frente, daí a necessidade do 'break'.

[Igor L Marques]

Isso acontece sim, Vanessa.
Esse é o comportamento do switch-case.

Há situações (dependendo do domínio da aplicação) que um determinado comportamento deve ser executado para mais de um case.

[]'s

2008/11/14 Vanessa Leite <vanessinhal...@gmail.com>

--
Igor L Marques
MSc Candidate in Computer Science
Federal University of Pernambuco, Brazil

[Fabio A Mazzarino]

Vanessa:

O break serve exatamente para isso. E não é tão raro encontrar
construções em que o não uso do break é muito interessante.

Imagine um hardware que pode ser desligado, ligado ou reiniciado:

switch(cmd) {
case CMD_STOP:
stop_glitch();
break;

case CMD_RESTART:
stop_glitch();

case CMD_START:
start_glitch();
break;
default:
msg_cmd_not_found(cmd);
}


CMD_STOP - pára o hardware
CMD_START - inicia o hardware
CMD_RESTART - pára e depois inicia o hardware

Fabio


--

Doses Diárias - Achados de um Programador na Internet
http://dosesdiarias.seucaminho.com

2008/11/14 Vanessa Leite <vanessinhal...@gmail.com>:

[Gianni Rossi]

On Friday 14 November 2008 17:58:03 Juliano F. Ravasi wrote:
> Renne Rocha wrote:
> > Esse comportamento é util sim... evita muita duplicação de código em
> > condicionais com vários operadores OR... dou manutenção em alguns
> > sistemas que sem essa construção virariam um monstro de IFs para dar
> > manutenção...
>
> Outro bom exemplo é o "Dispositivo de Duff", uma forma de otimização de
> laços: http://en.wikipedia.org/wiki/Duff's_device
>
> O 'switch' tem esse aspecto porque ele é basicamente uma forma de
> 'goto'. Os 'case's e o 'default' são representados como rótulos
> (terminados em ":"), e devem ser considerados como tal, ou seja, a
> execução passa através do rótulo. O 'switch' é um 'goto' controlado pelo
> valor da expressão fornecida, que pula a execução para um determinado
> rótulo, e continua dali para frente, daí a necessidade do 'break'.

Meio OT, mas não muito; o post inicial era sobre um switch que iria 'analizar' a entrada de um usuário, que obrigatóriamente tinha que ser númerica. Muitas linguagens permitem switch/case de strings (Pascal, PHP, etc). Em C/C++ isso não é permitido. Porém existe uma ferramenta muito legal para isso que 'o gperf (http://www.gnu.org/software/gperf/manual/gperf.html). Ele basicamente transforma as opções ("Salgado", "Doces", etc) em hashes em tempo de compilação. Aí, ele pega o string do usuário e faz o hash daquilo. Assim, podendo-se fazer o switch/case. Dá um pouquinho de trabalho, mas em casos onde há muitas opções e/ou necessidade de performance é uma boa.

O código fica mais ou menos assim:

int opcao = uma_classe::has( str_do_usuario );

switch ( opcao )
{
case uma_classe::SALGADO: // isto é um enum
cout << "Escolheu salgado" << endl;
break;
case uma_classe::DOCE:
cout << "Escolheu doce" << endl;
break;
[...etc...]
}

[Wanderley Caloni]

Sem dúvida o não-uso do break pode ser útil, apesar de não ser a
maioria dos casos.

No entanto, por costume e uso diário de todos que programam na
linguagem e aprenderam a usar o break, e até mesmo por muitas vezes a
falta do break ser um bug mesmo, costumo comentar sua ausência, para
deixar claro que eu sei o que estou fazendo:

switch( expression )
{
case 1:
doSomething();
// SIM, não tem o break mesmo (ou algum outro comentário que
explique sua ausência)

case 2:
doSomethingMore();
break;

default:
assert(false); // ou qualquer outro controle de erro
break.
}

Além disso, como pode ser notado, também costumo sempre colocar um
default em casos abertos para detectar maus uso da função, um bug em
potencial.

[]s

On 14 nov, 15:33, "Fabio A Mazzarino" <fabio.mazzar...@gmail.com>
wrote:

>  Vanessa:
>
>  O break serve exatamente para isso. E não é tão raro encontrar
> construções em que o não uso do break é muito interessante.
>
>  Imagine um hardware que pode ser desligado, ligado ou reiniciado:
>
> switch(cmd) {
>     case CMD_STOP:
>         stop_glitch();
>         break;
>
>     case CMD_RESTART:
>         stop_glitch();
>
>     case CMD_START:
>         start_glitch();
>         break;
>     default:
>         msg_cmd_not_found(cmd);
>
> }
>
> CMD_STOP - pára o hardware
> CMD_START - inicia o hardware
> CMD_RESTART - pára e depois inicia o hardware
>
>  Fabio
>
> --
> Doses Diárias - Achados de um Programador na Internethttp://dosesdiarias.seucaminho.com
>

> 2008/11/14 Vanessa Leite <vanessinhaleite.cp.u...@gmail.com>:

>
>
>
> > Isso acontece mesmo?
>
> > Nao parece me fazer muito sentido. Afinal, se a variavel b possui valor 1,
> > pq entrar no case 2?
>
> > Penso que o break serve pra uma otimização ou algo assim, pra nao fazer
> > iterações desnecessarias. Nao seria isso?
>

> > 2008/11/14 Fabio A Mazzarino <fabio.mazzar...@gmail.com>

> >> 2008/11/13 Eduardo Arruda <duduzau...@gmail.com>:

>
> >> > Mas não seria bom usar o break?? Evitaria comparações?
>

> >> > 2008/11/13 Hélder Gomes <orspee...@gmail.com>:

[Vanessa Leite]

Mas o switch-case não faz o teste? Eu apesar de "entender" a utilidade desse comportamento, nao o aceito.
se minha variavel tem valor 1, dai vem o primeiro teste: 'case 4', ele simplesmente entra e executa as instruções??

Oo

2008/11/15 Wanderley Caloni <wanderl...@gmail.com>

[Pedro d'Aquino]

Pense no switch/case da seguinte forma:

switch(i) {

  case 1: printf("1");

  case 2: printf("2");

}

Esse código, que, note, não tem breaks ao fim de cada case, é equivalente ao seguinte:

if(i == 1) goto L1;

if(i == 2) goto L2;;

L1: printf("1");

L2: printf("2");

Perceba como, se i == 1 tanto "1" quanto "2" serão impressos. Já se houvesse um break:

switch(i) {

  case 1: printf("1"); break;

  case 2: printf("2"); break;

}

/* resto do programa */

Isso é equivalente a:

if(i == 1) goto L1;

if(i == 2) goto L2;

L1: printf("1"); goto FIM;

L2: printf("2"); goto FIM;

FIM: 

/* resto do programa */

(por favor, se falei alguma bobagem, me corrijam!)

É exatamente por esse comportamento ser contra-intuitivo que eu acho sua presença na linguagem questionável. Sem a menor dúvida, como vários colegas apontaram, há diversas situações em que o "fall through" é útil. Contudo, em todos os cenários uma outra abordagem é possível, e, por vezes, mais clara.

De qualquer modo, o melhor conselho é o do Wanderley: quando você omitir o "break", deixe explícito num comentário sua intenção e propósito.

2008/11/15 Vanessa Leite <vanessinhal...@gmail.com>

[Felipe Goron Farinon]

O switch case é como se fosse uma tabela gigante de goto's. Caso ele fosse implementado do jeito que tu sugeriu ele não teria nenhuma vantagem em comparação ao if, ai não teria sentido o valor dos cases ser constante apenas. A implementação é mais ou menos a seguinte:

switch (x)
{
   case 1: std::cout << "1"; break;
   case 2: std::cout << "2"; break;
}

Assembly gerado:

00BB1011   MOV EAX, DWORD PTR SS:[ESP+4]; // move o valor da variável x para o registrador eax
[...]
00BB101F  JMP DWORD PTR DS:[EAX*4+BB1140]; // da um pulo de acordo com o valor do registrador eax
[...]
00BB1026 // case 1
00BB103F // case 2

Ou seja, o operando do JMP irá receber um valor que varia de acordo com o valor de EAX, dependendo dos cases o calculo que é feito no JMP muda bastante mas a idéia sempre é a mesma, pular de maneira constante para um pedaço de código. Fazendo referência ao Big-O poderíamos considerar o switch sendo de complexidade O(1) enquanto uma sequência de if sendo O(n).

2008/11/15 Pedro d'Aquino <bud...@gmail.com>

--
- Felipe Farinon

[Juliano F. Ravasi]

Pedro d'Aquino wrote:
> É exatamente por esse comportamento ser contra-intuitivo que eu acho sua
> presença na linguagem questionável. Sem a menor dúvida, como vários
> colegas apontaram, há diversas situações em que o "fall through" é útil.
> Contudo, em todos os cenários uma outra abordagem é possível, e, por
> vezes, mais clara.

Talvez pudéssemos sugerir isso para os comitês de padronização da
linguagem. C99 e C++0x foram desenvolvidos através do feedback dos
próprios programadores.

Poderia ser sugerido uma nova sintaxe de switch/case de mais alto nível,
totalmente distinta da atual, por exemplo:

switch (test) {
case(1) {
...
}
case(2) {
...
}
default {
...
}
}

Basicamente, para diferenciar do uso antigo, exigir '(' como próximo
token depois do 'case', e BlockStatement ao invés de ':' após a
expressão de teste.

Uma coisa que teria que se pensar é sobre o caso:

case 1:
case 2:
case 3:

...
break;

Uma possibilidade talvez seria:

case(1, 2, 3) {
...

[Vanessa Leite]

O que me deixa bem confusa por sinal é esse tratamento estranho.
Assim, se eu tiver, variavel de valor 2:

case 1: faca isso;
case 2: faca aquilo;

o programa faz isso e aquilo.

mas se tiver:

case 1: faca isso;break;
case 2: faca aquilo;break;

ele faz só aquilo. Mesmo tendo executado o primeiro teste nao? e ele entra nas instruções nao? e encontra um break nao? mas nao executa e nem pára!!

Aff.. to ficando doida.

2008/11/16 Juliano F. Ravasi <m...@juliano.info>

[Hélder Gomes]

Nossa, eu acho o switch muito simples e interessante! Como disseram antes ele é uma tabela de GOTOs...

Eu acho que eu entendo switch porque já programei em BASIC (me arrependo disso profundamente :P, principalmente porque fiquei usando GOTO no C um bom tempo... eca :P)

2008/11/16 Vanessa Leite <vanessinhal...@gmail.com>

[Felipe Goron Farinon]

O tratamento não é estranho, é bem normal:

switch (x)
{
case 1: [comando]
case 2: [comando]
case 3: [comando]
}

se x for 1 ele irá executar 1, 2 e 3
se x for 2 ele irá executar 2 e 3
se x for 3 ele irá executar 3

O switch é um "fall-trough" ele vai pro case certo, e vai executando qualquer coisa que achar pelo caminho até achar um break. quando achar o break ele sai do switch.

--
- Felipe Farinon

[Fabricio Melo]

essa explicação tirou minhas duvidas, vlw Felipe!

 

Fabricio

2008/11/16 Felipe Goron Farinon <felipe....@gmail.com>

[Vanessa Leite]

Pois eh, vc diz que ele vai executando qualquer coisa até encontrar um break..
nesse seu codigo ai, se tivesse o break em cada um dos case's ele só executaria o comando "correto" não é?
Ele não sairia "entrando" em cada case.. se for executando qualquer coisa até encontrar um break, ele deveria executar o primeiro e parar nao?

2008/11/16 Felipe Goron Farinon <felipe....@gmail.com>

O tratamento não é estranho, é bem normal:

[Felipe Goron Farinon]

Isso mesmo, se a construção for dessa maneira:

switch (x)
{
case 1: [comando]; break;
case 2: [comando]; break;
case 3: [comando]; break;
}

Então só o comando "correto" seria executado.

2008/11/16 Vanessa Leite <vanessinhal...@gmail.com>

--
- Felipe Farinon

[Felipe Goron Farinon]

À disposição ;)

2008/11/16 Fabricio Melo <guia...@gmail.com>

--
- Felipe Farinon

[Fabio A Mazzarino]

 Vanessa:

 Não vou insistir no case pq eu vi que vc está entendendo, apesar de não concordar.

 Esta construção vem de décadas atrás, e sempre foi assim, duvido muito que em alguma versão futura seja alterada. É uma construção que muitos programadores C se gabam de poder fazer, enquanto que em outras linguagens isso nã é possível.

 Mas se vc acho isso estranho, espere até descobrir as construções malucas que podem aparecer ao descobrir que o for é na verdade um while. Coisas como:

for (ct = nEntries; ct--; ) {
    // comandos aqui

}

 Fabio

--
Doses Diárias - Achados de um Programador na Internet
http://dosesdiarias.seucaminho.com

2008/11/16 Vanessa Leite <vanessinhal...@gmail.com>

[Gabriel Silva Moreira]

for(p != NULL;p++)
{
  ....
}

while (p != NULL)
{
 p++;
 ....
}

(podemos fazer o q quiser está é a magia do C)

2008/11/17 Fabio A Mazzarino <fabio.m...@gmail.com>

[Gabriel Silva Moreira]

correção:
for(;p != NULL;p++)
{
  ....
}

2008/11/17 Gabriel Silva Moreira <newbi...@gmail.com>

[Vanessa Leite]

Nao tenho problemas em entender o for como um while..
Na verdade já usei muito ele dessa maneira, chegando a fazer até algo como:

for(;;){
...
}

com algum if que entrava no break pra termina-lo.

Saber como o case funciona, jah entendo perfeitamente. Só não concordo que seja assim.
Mas fazer oq  neh?

Obrigada a todos.

[Rodrigo Delduca (skhaz)]

lembrei disso, um hack do gcc

switch (major_idx)
{
case 0:
return SCSI_DISK0_MAJOR;
case 1 ... 7:
return SCSI_DISK1_MAJOR + major_idx - 1;
case 8 ... 15:
return SCSI_DISK8_MAJOR + major_idx - 8;
default:
BUG();
return 0; /* shut up gcc */
}

referencia http://www.ibm.com/developerworks/linux/library/l-gcc-hacks/index.html

[Rodrigo Delduca (skhaz)]