Newsgroup: it.comp.lang.c++
Titolo: c++ e Array variabili

Salve,sto scrivendo un programma che ha due classsi una derivata dall'altra
(mazzo, quella base e mazzoNapolatano quella derivata).
Definisco in quella base un'array( il mazzo delle carte) che deve cambiare
in funzione della classe derivata.
class Mazzo{
protected : int numCarte
public:
Mazzo();
Mazzo(int numeroCarte);
CartaDaGioco mazzomescolato[numCarte];
}
class MazzoNapoletano: public Mazzo{
mazzoNapoletano(){Mazzo(40);}
}
Il  compilatore mi dice che  non può creare mazzomescolato[numCarte] in
quanto numCarte non è costante., o meglio l'errore è Constant Expression
Required.
Come posso risolvere questo problema oltre a definire tutto in
mazzoNapoletano?
grazie in Anticipo.

 Required.
#include<iostream>
using namespace std;
class Mazzo{
    protected:
        int numCarte;
    public:
        Mazzo(){
            mazzomescolato=NULL;
            numCarte=0;
        }
        Mazzo(int numeroCarte):numCarte(numeroCarte){
            mazzomescolato=new int[numCarte];
        }
        ~Mazzo(){
            if(mazzomescolato){
                delete[] mazzomescolato;
            }
        }
        int *mazzomescolato;
};
class MazzoNapoletano: public Mazzo{
    public:
        MazzoNapoletano():Mazzo(40){
            // codice del costruttore:
        }
};
int main()
{
    MazzoNapoletano a;
    a.mazzomescolato[12]=4;
    cout << a.mazzomescolato[12] << endl;
    return 0;
}
Tommy

 wrote in message
news:2fjR9.52112$Q%4.17...@news1.tin.it...

Cambi
da CartaDaGioco mazzomescolato[numCarte];
a  CartaDaGioco *mazzomescolato;
facendolo diventare un puntatore a CartaDaGioco, che assumera' il valore
iniziale di un blocco di memoria che allocherai dinamicamente al momento
della costruzione di Mazzo.
Mazzo (int numeroCarte) {mazzomescolato = new CartaDaGioco[numeroCarte];}
Ti riposto il codice perche' ci sono degli errori di sintassi (mancano
diversi punti e virgola alla fine delle classi e il distruttore di Mazzo ora
dovra' essere virtuale):
class CartaDaGioco
{
   int iCarta; // giusto per iniziare
};
class Mazzo
{
protected :
   int numCarte;
public:
   Mazzo();
   Mazzo(int numeroCarte) {mazzomescolato = new CartaDaGioco[numeroCarte];}
   virtual ~Mazzo() {delete []mazzomescolato;}
   CartaDaGioco *mazzomescolato;
};
class MazzoNapoletano: public Mazzo
{
   MazzoNapoletano(){Mazzo(40);}
};
int main()
{
        // gioca!
        return 0;
}
Maurus


Vorrei Creare una funzione mescolamazzo che sia membero della classe Mazzo e
quindi che venga ereditata da tutte le sottoclassi che funzioni su numCarte
di Mazzo. Sui ";" hai ragione ma non era cruciale per la spiegzazione del
problema!
 garzie

 Tommy
Anche se in tutta franchezza se usi vector eviti il problema!!!! e fai
prima!!!!
Tommy

  garzie
Non capisco quale sia il problema nel creare la funzione mescolamazzo se
spieghi il tuo problema o/e la tua difficolta' dopo ti aiuto volentieri!!!
(cosi' non sapendo quale e' il problema non so cosa dire)
Tommy

 ha scritto nel messaggio
news:av4m7d$1ik$1...@venus.btinternet.com...

ho una classe mazzoclass Mazzo{
protected: int numCarte;
public:
 CartaDaGioco *mazzoMescolato;
 Mazzo();
 Mazzo(int numcarte);
 };
---e una classe mazzoNapoletano
class MazzoNapoletano: public Mazzo{
public: MazzoNapoletano();
//CartaDaGioco mazzoMescolato[40];
 };
 ora voglio definire un metodo della classe Mazzo che me lo deve mescolare
(mescolamazzo), ma  tale metodo deve poter essere applicabile...
Problema : numCarte viene assegnato nelle sottoclassi ma č importante per
mescolare il mazzo
CartaDaGioco č una classe, spero di essere stato un po' chiaro!

 CartaDaGioco č una classe, spero di essere stato un po' chiaro!
Allora o usi il valore di numCarte che puoi leggere dalla derivata e
mescolare li il mazzo (sconsigliata).
Oppure metti la funzione per mescolare il mazzo nella classe base e poi la
chiama dalla derivata tutte le volte che ti serve.
Non capisco quale sia il problema.
numCarte viene assegnato nelle sottoclassi, ma allora?!?!? Una funz. membro
della base vi ci pio' sempre accedere visto che la variabile viene
dichiarata nella funzione base!
Il fatto che cartadagioco sia una classe o un int, a questo proposito (e
nell'esempio che ti ho postato) non e' rilevante.
metti void mescolamazzo(); nella base e chiamala dalla derivata.
tale metodo controllera' il valore di numCarte.
Forse sono ceco io, ma... non vedo il problema.
Tommy


Prova se ti va bene questo abozzo:
#include <iostream>
enum SemeNapoletane {SPADE, BASTONI, COPPE, DENARI};
class CartaDaGioco
{
public:
   CartaDaGioco() : m_valCarta(1), m_semeCarta(0) {}
private:
   int m_valCarta;
   int m_semeCarta;
};
class Mazzo
{
protected :
   int numCarte;
   int numSemi;
public:
   Mazzo() : numCarte(0), numSemi(0) { std::cout << "Costruisco il mazzo di
default" << std::endl;}
   Mazzo(int numeroCarte, int numeroSemi);
   virtual void mescolaMazzo();
   virtual  CartaDaGioco dammiCarta();
   virtual ~Mazzo() {delete []mazzomescolato; std::cout << "Distruggo il
mazzo" << std::endl;}
   CartaDaGioco *mazzomescolato;
};
Mazzo::Mazzo(int numeroCarte, int numeroSemi)  : numCarte(numeroCarte),
numSemi(numeroSemi)
{
   std::cout << "Costruisco il mazzo " << numCarte << " Carte " << numSemi
<< " Semi " << std::endl;
   mazzomescolato = new CartaDaGioco[numeroCarte];
}
void Mazzo::mescolaMazzo()
{
   std::cout << "Mescolo il mazzo" << std::endl;
}
CartaDaGioco Mazzo::dammiCarta()
{
   CartaDaGioco Dummy;
   std::cout << "Dammi una carta dal mazzo" << std::endl;
   return Dummy;
}
class MazzoNapoletano: public Mazzo
{
public:
   MazzoNapoletano();
   void mescolaMazzo();
   CartaDaGioco dammiCarta();
   ~MazzoNapoletano() {std::cout << "Distruggo il mazzo napoletano" <<
std::endl;}
private:
   enum {NCARTE = 40, NSEMI = 4};
};
MazzoNapoletano::MazzoNapoletano() : Mazzo(NCARTE, NSEMI)
{
   std::cout << "Costruisco il mazzo napoletano" << std::endl;
}
CartaDaGioco MazzoNapoletano::dammiCarta()
{
   CartaDaGioco Carta;
   std::cout << "Dammi una carta dal mazzo napoletano" << std::endl;
   return Carta;
}
void MazzoNapoletano::mescolaMazzo()
{
   std::cout << "Mescolo il mazzo napoletano" << std::endl;
}
int main()
{
   {
      MazzoNapoletano mn;
      mn.mescolaMazzo();
      mn.dammiCarta();
   }
   system("PAUSE");
   return 0;
}
Maurus

 tale metodo controllera' il valore di numCarte.
Forse hai ragione, e' piu' corretto lasciare mescolamazzo() sulla classe
base senza farla virtuale come ho fatto io.
Maurus

 ha scritto nel messaggio
news:av4qo0$ckc$1...@helle.btinternet.com...


ok dopo aver creato  mazzomescolato =new CartaDaGioco[numCarte], per
accedere ai vari elementi
devo utilizzare mazzomescolato[0]........mazzomescolato[n]?
Per mescolaMazzo non sono convinto ma appena ho provato Vi faccio sapere!

 Per mescolaMazzo non sono convinto ma appena ho provato Vi faccio sapere!
Ok!
Tommy

 il compilatore mi dice che non è possibile
che cosa non e' possibile ?!?!?
Forse l'hai implementato tu male.... quello che dico, se implementato bene
e' possibile!
Tommy

 > il compilatore mi dice che non č possibile
