Newsgroup: it.comp.lang.c++
Titolo: Switch case

Salve a tutti.
Si può fare questo in uno switch case:
switch(x){
    case 1:  char* T=new char[num];break;
    case 2:  int* T=new int[num];break;
    case 3:  float* T=new float[num];
}
Grazie

Apoc ha scritto:

Sintatticamente e' corretto, ma dopo la "}" la variabile T non sara'
visibile quindi, non serve a nulla.
-- 
"Con questo cosa voglio dire? Non lo so. Pero' c'ho ragione."
(Palmiro Cangini)

 visibile quindi, non serve a nulla.
Ciao, grazie per avermi risposto.
Il listato completo è questo.
Allora come faccio?
/****************************************************************/
void main(){
    int num;
    cout << "\nInserisci il numero di elementi:";
    cin >>num;
    int x;
    cout <<"\nPremere 1 per un array di caratteri";
    cout <<"\nPremere 2 per un array di interi";
    cout << "\nPremere 3 per un array di reali";
    cout << "\n-->:";
    cin >> x;
    switch(x){
    case 1:  char* T=new char[num];break;
    case 2:  int* T=new int[num];break;
    case 3:  float* T=new float[num];
    }
    for(int i=0;i<num;i++){
       cout << "\nInserisci l'elemento numero "<< i+1 << ":";
       cin >> V[i];
    }
    cout << "\nVettore ordinato:" << endl;
    Quick (V,num);
    for(int k=0; k<num;k++){
       cout << " " << V[k];
    }
    cout << endl;
    delete [] V;
    system("PAUSE");
}
/***************************************************************************
*********/

[...]
Allora, io ci vedo alcuni errori concettuali:
1. (opinabile) non vedo programmazione ad oggetti, vengono giusto usati gli
operatori << e >> per leggere e scrivere e gli operatori new e delete per
gli array. Ok, ok, ho detto che e' opinabile ;) e' chiaro che non si puo'
giudicare da un listato cosi' corto :)
2. tu devi ALMENO sapere in un certo punto del programma CHE TIPO usi! La
determinazione del tipo (e quindi di quanta memoria occupa una variabile/un
oggetto) avviene compile-time! Cio' che vuoi fare si puo' fare, ma IMHO e'
troppo complicato ed inutile: dovresti usare dei puntatori a void, e fare
*ogni volta* il cast al tipo che desideri... anche usando i template in
questo caso, devi fare il cast in modo che il *compilatore* possa stabilire
con che tipo si sta "giocando"...


 Allora come faccio?
Il C++ e' un linguaggio strong typed; se tu vuoi una variabile che
possa essere contemporaneamente un puntatore a intero, carattere o
float vai contro la filosofia del linguaggio.  Si puo' fare, ma e'
meglio evitarlo.  Inoltre: il C++ possiede una standard library, che
e' meglio usare; i suoi sort etc. sono molto piu' efficienti dei
tuoi.  Poi: perche' dichiari un puntatore di nome T e scrivi in
qualcosa che si chiama V?  Poi: void main e' un grosso errore.
Poi... beh, prova con qualcosa del genere (NON TESTATO)
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
vector<int> vI;
vector<double> pD;
// Non importa dire quanti sono gli elementi del vettore
// Fatti dire il tipo dei dati, e.g. 1 per interi, ...
switch (x) {
  case 1:
    copy(istream_iterator<int>(cin), istream_iterator<int>(),
         back_inserter(vI));  // Qui leggi tutti i tuoi dati
    sort(vI.begin(), vi.end());  // Qui li ordini
    copy(vi.begin(), vi.end(), ostream_iterator(cout, "\n"));  // Qui li
                                                                  stampi
    break;
  case ...
}
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Dept. of Physics, Univ. of Padova, Italy          loreti at pd dot infn dot it

Poi: void main e' un grosso errore.
Perche'?


 con che tipo si sta "giocando"...
Quello che volevo fare è un algoritmo Quick Sort generico, tramite TEMPLATE.
Questo è il resto del prog, il file .h:
/***************************************************************************
*********************/
template <class T> void separa(T* lista, const int primo, const int ultimo,
int & i, int & j){
        i=primo;
        j=ultimo;
        T x=lista[(primo+ultimo)/2];
        do{
        while(lista[i]<x) i++;
        while(x<lista[j]) j--;
           if(i<=j){
              T temp=lista[i];
              lista[i]=lista[j];
              lista[j]=temp;
              i++;
              j--;
           }
        }while(i<=j);
}
template <class T> void ordina(T* lista, const int primo, const int ultimo){
        int s,d;
        separa (lista,primo,ultimo,s,d);
        if(primo<d) ordina (lista, primo, d);
        if(s<ultimo) ordina (lista, s, ultimo);
}
template <class T> void Quick(T* lista, const int dim){
        ordina (lista,0,dim-1);
}
/***************************************************************************
*********************************/

 tuoi.
Si ma a me non interessa per ora l'efficienza, io devo imparare
l'algoritmo......

 Perche'?
Perche' cosi' dice lo Standard.  void main e' undefined behavior.  Il
valore ritornato da main viene passato all'ambiente chiamante
(l'underlying OS).  In particolare, esistono sistemi operativi nei
quali una procedura che ritorna un valore ed una che non ritorna nulla
vengono chiamate con istruzioni assembler differenti; e quindi void
main puo' casuare un crash.
Per maggiori informazioni puoi leggere la FAQ list di comp.lang.c,
sotto la URL 
http://www.eskimo.com/~scs/C-faq/top.html
, ed in
particolare le Q/A da 11.12 a 11.15 .


 l'algoritmo......
Ed in cosa l'algoritmo e' differente, se cambia il tipo dei dati?
Quello che importa e' la sola disponibilita' di una funzione di
confronto (operator <).  Limitati agli interi, quindi.




No. 
I singoli 'case' non hanno scope separato, rispetto a quello dello
'switch'.
In C++ non è consentito (il programma sarebbe ill-formed) saltare (via
'goto' o 'switch/case') da un punto in cui una variabile non è visibile
nello scope a un punto in cui lo è, se non nel caso in cui la variabile è
di tipo POD e la dichiarazione è priva di 'initializer'.
Nel tuo caso particolare, per altro, il simbolo T dovrebbe nello stesso
scope riferirsi a tre variabili distinte e ciò non è, ovviamente,
possibile.
Max

 confronto (operator <).  Limitati agli interi, quindi.
Intendevo l'algoritmo dei template.........

di tipo POD e la dichiarazione č priva di 'initializer'.
Cosa sono le variabili POD?


Intendevo l'algoritmo dei template.........
Le alternative sono due:
(1) Sei un troll
(2) Hai le idee mooolto confuse
Che cappero significa "l'algoritmo dei template"???


[...]
Basta quindi mettere int void(), e far ritornare 0?


> Basta quindi mettere int void(), e far ritornare 0?
magari "int main(void)"...............

> Che cappero significa "l'algoritmo dei template"???
Scusa ma per te che vuol dire algoritmo?

magari "int main(void)"...............
In C++ non e' necessario specificare (void) se la funzione non ha parametri.
In C "<tipo> <nomefunzione>()" significa che i parmetri non sono
specificati, in C++ significa che non ci sono parametri (equivalente a
<tipo> <nomefunzione>(void)".


Scusa ma per te che vuol dire algoritmo?
Algoritmo = Sequenza finita, terminante e non ambigua istruzioni.
Ora dimmi tu: cosa significa "l'algoritmi dei template"?


Algoritmo = Sequenza finita, terminante e non ambigua *di* istruzioni.


 a écrit dans le message
news: ah0umd$2jf$7...@newsreader.mailgate.org...

Voleva dire:
l'algoritmo del quicksort implementato con l'ausilio dei templates (funzione
template), piuttosto che utilizzare una funzione con tipi ben definiti per
cui limitata.
Maurus

 Cosa sono le variabili POD?
Plain Old Data... int, float, char ecc...
Da escludersi, ad esempio string e simili...
-- 
Luc.

 
Plain Old Data. Definizione ricorsiva:
  - un tipo built-in è un tipo POD
  - una struct, priva di costruttore/distruttore "non trivial",
     contentente solo membri POD è un tipo POD
Max

cui limitata.
L'algoritmo, sia usi sia non usi i template, e' lo stesso, non cambia
*nulla*! Forse il nostro amico non ha ben chiaro lo scopo dei template


 a écrit dans le message
news: ah1be5$ft9$2...@newsreader.mailgate.org...

Copiato e incollato dal messaggio di Apoc delle 12:26
"....Quello che volevo fare è un algoritmo Quick Sort generico, tramite
TEMPLATE.
Questo è il resto del prog, il file .h:
..."
Per cui penso che il nostro amico sappia che l'algoritmo rimane lo stesso a
prescindere dall'uso dei templates. Era solo un problema di chiarezza.
Maurus

 cui limitata.
Infatti, forse Francesco Sblendorio crede che implementare un Template non
significhi stendere un algoritmo........

Allora, "void main()" e' standard o no?
No
-- 
Marco Barisione (ICQ 84277092)

significhi stendere un algoritmo........
Non ci capiamo: se devi studiare l'algoritmo del quicksort, lo puoi fare
indipendentemente dai template, sono due argomenti ortogonali.
L'algoritmo del quicksort *non cambia* se non usi i template. Cio' che
cambia e' l'implementazione, limitatamente alla interfaccia della funzione
ed alla dichiarazione delle variabili che, da che mondo e mondo, *non* fa
parte dell'algoritmo



Esistono OS che si aspettano un valore di ritorno di una funzione nello
STACK?!?!?
Ommamma...
Ciaotutti,
*

Ommamma...
Allora, "void main()" e' standard o no?
-- 


No
E perche'? Nel post precedente si diceva perche' alcuni OS possono crashare
non vedendosi restituire nulla, ma poi la tesi e' stata smentita.
C'e' allora un motivo?


 C'e' allora un motivo?
Si che c'e'.  Hai letto le FAQ che ti avevo consigliate?
Evidentemente no.  Fallo: ecco qui...
,-----
| 11.12a: What's the correct declaration of main()?
| 
| A:      Either int main(), int main(void), or int main(int argc,
|         char *argv[]) (with alternate spellings of argc and *argv[]
|         obviously allowed).  See also questions 11.12b to 11.15 below.
| 
|         References: ISO Sec. 5.1.2.2.1, Sec. G.5.1; H&S Sec. 20.1 p.
|         416; CT&P Sec. 3.10 pp. 50-51.
| 
| 11.12b: Can I declare main() as void, to shut off these annoying
|         "main returns no value" messages?
| 
| A:      No.  main() must be declared as returning an int, and as
|         taking either zero or two arguments, of the appropriate types.
|         If you're calling exit() but still getting warnings, you may
|         have to insert a redundant return statement (or use some kind
|         of "not reached" directive, if available).
| 
|         Declaring a function as void does not merely shut off or
|         rearrange warnings: it may also result in a different function
|         call/return sequence, incompatible with what the caller (in
|         main's case, the C run-time startup code) expects.
| 
|         (Note that this discussion of main() pertains only to "hosted"
|         implementations; none of it applies to "freestanding"
|         implementations, which may not even have main().  However,
|         freestanding implementations are comparatively rare, and if
|         you're using one, you probably know it.  If you've never heard
|         of the distinction, you're probably using a hosted
|         implementation, and the above rules apply.)
| 
|         References: ISO Sec. 5.1.2.2.1, Sec. G.5.1; H&S Sec. 20.1 p.
|         416; CT&P Sec. 3.10 pp. 50-51.
| 
| 11.13:  But what about main's third argument, envp?
| 
| A:      It's a non-standard (though common) extension.  If you really
|         need to access the environment in ways beyond what the standard
|         getenv() function provides, though, the global variable environ
|         is probably a better avenue (though it's equally non-standard).
| 
|         References: ISO Sec. G.5.1; H&S Sec. 20.1 pp. 416-7.
| 
| 11.14:  I believe that declaring void main() can't fail, since I'm
|         calling exit() instead of returning, and anyway my operating
|         system ignores a program's exit/return status.
| 
| A:      It doesn't matter whether main() returns or not, or whether
|         anyone looks at the status; the problem is that when main() is
|         misdeclared, its caller (the runtime startup code) may not even
|         be able to *call* it correctly (due to the potential clash of
|         calling conventions; see question 11.12b).
| 
|         It has been reported that programs using void main() and
|         compiled using BC++ 4.5 can crash.  Some compilers (including
|         DEC C V4.1 and gcc with certain warnings enabled) will complain
|         about void main().
| 
|         Your operating system may ignore the exit status, and
|         void main() may work for you, but it is not portable and not
|         correct.
| 
| 11.15:  The book I've been using, _C Programming for the Compleat Idiot_,
|         always uses void main().
| 
| A:      Perhaps its author counts himself among the target audience.
|         Many books unaccountably use void main() in examples, and assert
|         that it's correct.  They're wrong.
`-----


E, per finire, ecco quello che dice il C++ (ISO/IEC 14882-1998) in
3.6.1.2
:
"An implementation shall not predefine the main function.  This
function shall not be overloaded.  It shall have a return type of type
int, but otherwise its type is implementation-defined.  All
implementations shall allow both of the following definitions of main:
int main() { /* ... */ } and int main(int argc, char* argv[]) { /*
... */ }."


C'e' allora un motivo?
Perchè uno std deve esserlo su tutti i sistemi operativi e non solo su
alcuni
--
Rhymes (
rhy...@myself.com
)
Brainbench Certification:
Language: Java 1, Score: 3.29, Date: 2001-10-02 
http://www.brainbench.com/transcript.jsp?pid=2435730

 parte dell'algoritmo
Forse è più attinente parlare di Template come "tecnica", ma dal punto di
vista dell'astrazione, non è anch'esso un particolare algoritmo?

vista dell'astrazione, non č anch'esso un particolare algoritmo?
Secondo me no. Direi "astrazione generica, implementata in C++ tramite il 
costrutto dei template".
