errore compilazione(c++)

[aquiral]

Salve a tutti, non riesco a capire l' errore di compilazione su questo programma, premetto che prima di utilizzare il costruttio switch nel main funzionava correttamente:

// Fig. 4.16: fig4_16.cpp
// Driver to test class Tree
#include <iostream>
#include <iomanip>
using namespace std;
using std::cout;
using std::cin;
using std::setiosflags;
using std::ios;
using std::setprecision;

#ifndef TREE_H
#define TREE_H
#include "treenode.h"
using std::endl;

template< class NODETYPE >
class Tree {
public:
Tree();
void insertNode( const NODETYPE & );
void preOrderTraversal() const;
void inOrderTraversal() const;
void postOrderTraversal() const;
private:
TreeNode< NODETYPE > *rootPtr;

// utility functions
void insertNodeHelper(
TreeNode< NODETYPE > **, const NODETYPE & );
void preOrderHelper( TreeNode< NODETYPE > * ) const;
void inOrderHelper( TreeNode< NODETYPE > * ) const;
void postOrderHelper( TreeNode< NODETYPE > * ) const;
};

template< class NODETYPE >
Tree< NODETYPE >::Tree() { rootPtr = 0; }

template< class NODETYPE >
void Tree< NODETYPE >::insertNode( const NODETYPE &value )
{ insertNodeHelper( &rootPtr, value ); }

// This function receives a pointer to a pointer so the
// pointer can be modified.
template< class NODETYPE >
void Tree< NODETYPE >::insertNodeHelper(
TreeNode< NODETYPE > **ptr, const NODETYPE &value )
{
if ( *ptr == 0 ) { // tree is empty
*ptr = new TreeNode< NODETYPE >( value );
assert( *ptr != 0 );
}
else // tree is not empty
if ( value < ( *ptr )->data )
insertNodeHelper( &( ( *ptr )->leftPtr ), value );
else
if ( value > ( *ptr )->data )
insertNodeHelper( &( ( *ptr )->rightPtr ), value );
else
cout << value << " dup" << endl;
}

template< class NODETYPE >
void Tree< NODETYPE >::preOrderTraversal() const
{ preOrderHelper( rootPtr ); }

template< class NODETYPE >
void Tree< NODETYPE >::preOrderHelper(
TreeNode< NODETYPE > *ptr ) const
{
if ( ptr != 0 ) {
cout << ptr->data <<" ";
preOrderHelper( ptr->leftPtr );
preOrderHelper( ptr->rightPtr );
}
}

template< class NODETYPE >
void Tree< NODETYPE >::inOrderTraversal() const
{ inOrderHelper( rootPtr ); }

template< class NODETYPE >
void Tree< NODETYPE >::inOrderHelper(
TreeNode< NODETYPE > *ptr ) const
{
if ( ptr != 0 ) {
inOrderHelper( ptr->leftPtr );
cout << ptr->data << " ";
inOrderHelper( ptr->rightPtr );
}
}

template< class NODETYPE >
void Tree< NODETYPE >::postOrderTraversal() const
{ postOrderHelper( rootPtr ); }

template< class NODETYPE >
void Tree< NODETYPE >::postOrderHelper(
TreeNode< NODETYPE > *ptr ) const
{
if ( ptr != 0 ) {
postOrderHelper( ptr->leftPtr );
postOrderHelper( ptr->rightPtr );
cout << ptr->data <<" " ;
}
}
#endif

#ifndef TREENODE_H
#define TREENODE_H

template< class NODETYPE > class Tree; // forward declaration

template< class NODETYPE >
class TreeNode {
friend class Tree< NODETYPE >;
public:
TreeNode( const NODETYPE &d )
: leftPtr( 0 ), data( d ), rightPtr( 0 ) { }
NODETYPE getData() const { return data; }
private:
TreeNode< NODETYPE > *leftPtr; // pointer to left subtree
NODETYPE data;
TreeNode< NODETYPE > *rightPtr; // pointer to right subtree
};

#endif




int main()
{
int scelta,x,i;
cout<<"\nChe tipo di dato vuoi inserire? "<<endl<<"1->Intero "<<endl<<"2->Reale "
<<endl<<"3->Carattere "<<endl<<"Scelta: ";
cin>>scelta;
switch(scelta) {
case '1':
Tree< int > intTree;
int intVal,x,i;
cout<<" \nQuanti valori vuoi inserire? ";
cin>>x;
cout << "\nInserire valori interi:"<<endl;
for( i = 0; i < x; i++ ) {
cin >> intVal;
intTree.insertNode( intVal );
}
cout << "\nVisita pre-ordine:\t";
intTree.preOrderTraversal();
cout << "\nVisita in-ordine:\t";
intTree.inOrderTraversal();
cout << "\nVisita post-ordine:\t";
intTree.postOrderTraversal();
break;
case '2':
Tree< double > doubleTree;
double doubleVal;
cout<<" \nQuanti valori vuoi inserire? ";
cin>>x;
cout << "\n\n\nInserire valori reali:"<<endl
<< setiosflags( ios::fixed | ios::showpoint )
<< setprecision( 1 );
for ( i = 0; i < x; i++ ) {
cin >> doubleVal;
doubleTree.insertNode( doubleVal );
}
cout << "\nVisita pre-ordine\t";
doubleTree.preOrderTraversal();
cout << "\nVisita in-ordine\t";
doubleTree.inOrderTraversal();
cout << "\nVisita post-ordine\t";
doubleTree.postOrderTraversal();
cout<<endl<<endl<<endl;
break;
case '3':
Tree< char > charTree;
char charVal;
cout<<" \nQuanti valori vuoi inserire? ";
cin>>x;
cout << "\n\n\nInserire caratteri:"<<endl;
for ( i = 0; i < x; i++ ) {
cin >> charVal;
charTree.insertNode(charVal );
}
cout << "\nVisita pre-ordine\t";
charTree.preOrderTraversal();
cout << "\nVisita in-ordine\t";
charTree.inOrderTraversal();
cout << "\nVisita post-ordine\t";
charTree.postOrderTraversal();
cout<<endl<<endl<<endl;
break;

default:
cout<<"Scelta incorretta, prego ripetere.";
break;
}

system("pause");
return 0;
}

[kk3z]

Sarebbe comodo sapere quali sono gli errori di compilazione... guardando così il codice: non puoi dichiarare variabili nei case a meno che tu non usi le graffe:

switch(...)
{
//errore
case 1:
int integer;
break;

//ok
case 2:
{
int integer;
}
break;
}

Ah, 1 è diverso da '1': ricavando un int dallo stdin perchè poi cerchi di confrontarlo con caratteri?
int scelta = 0;
cin << scelta;
switch(scelta)
{
case '1': //no!
case 1: //ok
}

[aquiral]

Giusto!!!
Ora non ho il compilatore sotto mano, posterò poi gli errori....
Intanto grazie per la risposta
Saluti

[trallallero]

cosí al volo vedo che fai dichiarazioni di variabili dentro il case dello switch :nonsifa:

devi mettere il tutto dentro { } ;)

[BountyKiller]

cosí al volo vedo che fai dichiarazioni di variabili dentro il case dello switch :nonsifa:

devi mettere il tutto dentro { } ;)


quelle sono definizioni...le dichiarazioni sono un'altra cosa ;) siamo nel 2007 vogliamo impararle queste cose o no??

int x; //definizione
int x=0; //definizione con inizializzazione

extern int Somma(int,int) ; // dichiarazione

[trallallero]

quelle sono definizioni...le dichiarazioni sono un'altra cosa ;) siamo nel 2007 vogliamo impararle queste cose o no??

int x; //definizione
int x=0; //definizione con inizializzazione

extern int Somma(int,int) ; // dichiarazione
:asd:

DEFINIZIONE (definisci un tipo)

struct pippo
{
...
};

DICHIARAZIONE (dichiari una variabile di tipo giá definito)

struct pippo P;

riprova, sarai piú fortunato :D

[BountyKiller]

:asd:

DEFINIZIONE (definisci un tipo)

struct pippo
{
...
};

DICHIARAZIONE (dichiari una variabile di tipo giá definito)

struct pippo P;

riprova, sarai piú fortunato :D


mi dispiace ma hai toppato tu :) se vuoi ti passo il libro di Bjarne... :D :D

[trallallero]

mi dispiace ma hai toppato tu :) se vuoi ti passo il libro di Bjarne... :D :D
avrá toppato anche lui allora ;)

[BountyKiller]

tralla non per far polemica...ma è così..fidati..le dichiarare una variabile in un sorgente significa dire affermare che quella variabile è definita in un altro file...

[trallallero]

tralla non per far polemica...ma è così..fidati..le dichiarare una variabile in un sorgente significa dire affermare che quella variabile è definita in un altro file...
ma quale polemica dai, per cose del genere :D

peró insisto, quando definisci un qualcosa fai un progetto, un piano, un alias, un'associazione, ma non concretizzi niente di niente. Quando decidi di mettere in pratica dichiari quindi allochi, concretizzi.
Quello che tu chiami dichiarazione quando fai:
extern int Somma(int,int) ; // dichiarazione
per me non é ne dichiarazione, ne definizione perché il dato (funzione) é giá definita (prototipo) ed esiste giá (extern).
Questo mi é stato insegnato, ci arrivi anche intuitivamente e lo trovi su tutti i libri di informatica in italiano, inglese e tutte le altre lingue del mondo.
Se questo tal dei tali alias:Bjarne un giorno si sveglia e vuole stravolgere le cose con puttanate senza senso son affari suoi, non lo considero proprio ;)

A questo punto perché non interviene qualche matusa guru o simili e dice la sua ?

[BountyKiller]

ma quale polemica dai, per cose del genere :D

peró insisto, quando definisci un qualcosa fai un progetto, un piano, un alias, un'associazione, ma non concretizzi niente di niente. Quando decidi di mettere in pratica dichiari quindi allochi, concretizzi.
Quello che tu chiami dichiarazione quando fai:
extern int Somma(int,int) ; // dichiarazione
per me non é ne dichiarazione, ne definizione perché il dato (funzione) é giá definita (prototipo) ed esiste giá (extern).
Questo mi é stato insegnato, ci arrivi anche intuitivamente e lo trovi su tutti i libri di informatica in italiano, inglese e tutte le altre lingue del mondo.
Se questo tal dei tali alias:Bjarne un giorno si sveglia e vuole stravolgere le cose con puttanate senza senso son affari suoi, non lo considero proprio ;)

A questo punto perché non interviene qualche matusa guru o simili e dice la sua ?


Bjarne = Bjarne Stoutrstrup...è solo il tizio che ha inventato il c++.

[trallallero]

Bjarne = Bjarne Stoutrstrup...è solo il tizio che ha inventato il c++.
ok, ma qui si parla di informatica non di C++. Voglio dire che la dichiarazione é dichiarazione in qualsiasi linguaggio, in C++ non é una ... exception

[BountyKiller]

dal titolo e dal main post mi pareva si parlasse di C++.. :boh:

[trallallero]

dal titolo e dal main post mi pareva si parlasse di C++.. :boh:
si é vero, ma poi ci siamo messi a discutere di dichiarazione/definizione che non mi sembrano concetti relativi al linguaggio.
Come dire, la grammatica in italiano é ina cosa in turco un'altra :D

[dierre]

Da quello che so io, anche se non mi sono fatto poi molte seghe mentali e di altro tipo in merito, è:

int x; // dichiari una variabile
int x=0; // dichiari con inizializzazione

extern int Somma(int,int) ; // dichiari un funzione

scruct bla { ... } //definisci

void pippo(){ ... } //definisci

poi se è scritto in inglese non è detto che "definition" è usata nella stessa accezione italiana.

[jappilas]

....
A questo punto perché non interviene qualche matusa guru o simili e dice la sua ?io (che sarò matusa ma guru dubito assai :D) dico solo che per quello che ricordo, per funzioni o metodi di classe, il solo prototipo costituisce la dichiarazione, l 'implementazione concreta la definizione....

per le variabili... dipende: ci sarebbe da fare un discorso più approfondito, perchè si tende a chiamare definizione di una variabile quello che da un pdv logico sarebbe la somma di due passi distinti,
l' aver in un certo punto del codice, istruito il compilatore sul nome identificativo e sul tipo da istanziare per quella variabile (la dichiarazione della variabile),
quello che tale istruzione comporta da parte del compilatore ( la risoluzione del tipo e l' allocazione di memoria per contenere la variabile stessa, in base al suo tipo ): la vera a propria definizione della variabile, attuata nel monento in cui si allocano fisicamente risorse per la variabile
ora, per variabili risolte direttamente o di tipi primitivi mappati su registri, la definizione è immediata e indistinta dalla dichiarazione (la specificazione delle risorse da allocare è effettuata atomicamente con la dichiarazione) ma è comunque interessate tenere presente la distinzione logica tra i due passi

rende chiaro da una parte perchè un tipo complesso (o esterno) debba sempre essere disambiguato o risolto, con una definizione concreta
ma soprattutto, come l' importanza che una variabile si trovi in una cella di memoria identificata da un indirizzo non ambiguo, implichi che la variabile sia allocata in memoria ( <> definita) una volta sola

e di conseguenza perchè il compilatore produce un errore quando si dichiara una variabile nello stesso scope, con lo stesso nome di un altra, o con un tipo definito in modo diverso ...

[trallallero]

prevedo una lunga vita per questo 3d ... siamo entrati in una discussione filosofica :D