[C++]classe chiama classe

[wizard_at]

ciao a tutti,
non sapevo come chiamare il tread...spero che non sia completamente sbagliato.

Avevo per voi una domanda che mi blocca in uno stupido progetto

io ho:

file ALFA.h

#include "BETA.h"
#include "mioogg.h"

class beta;

class alfa{
public:
mioogg* a;

alfa(){ 
a = new mioogg();
b = new beta(this); 
}
}

fiel BETA.h

#include "ALFA.h"
#include "mioogg.h"

class alfa;

class beta{
public:
mioogg* d;
beta(alfa* f){
d=f->a
}
}

corretto?

[jappilas]

mioogg.h viene incluso due volte, quel codice ti darà errore in compilazione - è meglio in questi casi usare le include guard

[wizard_at]

Originariamente inviato da jappilas

mioogg.h viene incluso due volte, quel codice ti darà errore in compilazione - è meglio in questi casi usare le include guard

non ho scritto tutto il codice...le include guard ci sono....

un secondo e posto il problema

[wizard_at]

file game.h

#ifndef _GAME_H_
#define _GAME_H_
#include <irrlicht.h>
#include "menu.h"

class menu;

using namespace irr;
using namespace core;
using namespace video;
using namespace scene;
using namespace gui;
//non uccidetemi x qst cosa
const int MEN=0;
const int GIOC=1;

class Game
{
public:
//stato del gioco
    int stato;
    menu* M;

	Game(){
        device = createDevice(EDT_SOFTWARE,dimension2d<s32>(640,480), 32, false, false, false, 0);

        stato = MEN;
    };


	void run(){
	    while(device->run()){
            switch (stato) {
                case MEN:
                M = new menu(this);
                stato=M->run();
                delete M;
                break;
            }
        }
        device->drop();
	};

    IrrlichtDevice *device;
};

#endif

file menu.h

#ifndef __MENO_H_INCLUDED__
#define __MENO_H_INCLUDED__

#include <irrlicht.h>
#include "Game.h"

using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

class Game;

class menu
{
public:
    menu(Game* gam){
        gioco=gam;
        device = gioco->device;
    };


    int run(){
        return 0;
    };
private:
    IrrlichtDevice *device;
    Game* gioco;
};

#endif

questo sono i miei file...
primo errore: forward declaration of 'struct Game'
secondo errore: invalid use of incomplete type 'struct Game'

spero di essere stato sufficientemente chiaro da poter essere soccorso

[cionci]

Intanto parti dividendo la dichiarazione delle classi dalle implementazioni.
Ricordati che la forward declaration serve solo in uno dei due file.

[wizard_at]

Originariamente inviato da cionci

Intanto parti dividendo la dichiarazione delle classi dalle implementazioni.
Ricordati che la forward declaration serve solo in uno dei due file.

ok grazie...ci provo

[DanieleC88]

Perché rendi pubbliche variabili interne alle classi che ne descrivono lo stato? Generalmente è preferibile farle private ed accedervi tramite getter.

[wizard_at]

Originariamente inviato da DanieleC88

Perché rendi pubbliche variabili interne alle classi che ne descrivono lo stato? Generalmente è preferibile farle private ed accedervi tramite getter.

questo e' un abbozzo per fare partire il tutto...poi va rifinito


cosa sono i getter?

PS:funziona ma non ho capito come ho fatto....ho smanettato/smadonnato un po sul codice e sui settaggi del progetto e allla fine funziona!

[cionci]

Originariamente inviato da wizard_at

cosa sono i getter?

PS:funziona ma non ho capito come ho fatto....ho smanettato/smadonnato un po sul codice e sui settaggi del progetto e allla fine funziona!

I getter e i setter sono semplici metodi per accedere rispettivamente in lettura e in scrittura alle variabili membro della classe. E' sempre meglio usarli in quanto sono più resistenti alle modifiche della rappresentazione interna dei dati (basta rinominare una variabile membro per dover rinominare ogni sua chiamata a giro per il codice). Inoltre permettono controlli sui valori impostati dagli utilizzatori della classe in modo da ottenere un utilizzo consistente della stessa.

class pippo
{
   int pippo;
public:
   pippo();
   int getPippo();
   void setPippo(int pippo);
};

getPippo e setPippo sono getter e setter per pippo.

Riguardo al codice, come ti dicevo, basta usare la forward declaration solo un volta e separare la dichiarazione dell'implementazione dalla classe:
ClassA.h

#ifndef CLASSA_H_INCLUDED
#define CLASSA_H_INCLUDED

class ClassB;

class ClassA
{
    ClassB *pippo;
public:
    ClassA(ClassB *pippo);
};

#endif // CLASSA_H_INCLUDED

ClassA.cpp

#include "ClassA.h"
#include "ClassB.h"

ClassA::ClassA(ClassB *pippo)
{
    this->pippo = pippo;
    pippo->setPluto(this);
}

ClassB.h

#ifndef CLASSB_H_INCLUDED
#define CLASSB_H_INCLUDED

#include "ClassA.h"

class ClassB
{
    ClassA *pluto;
public:
    ClassB();
    void setPluto(ClassA *pluto);
};

#endif // CLASSB_H_INCLUDED

ClassB.cpp

#include "ClassB.h"
#include "ClassA.h"

ClassB::ClassB()
{
}

void ClassB::setPluto(ClassA *pluto)
{
    this->pluto = pluto;
}

Come vedi la forward declaration viene fatta solo in un include. Questo perché l'include non contenendo l'implementazione di ClassA non richiede nemmeno l'implementazione di ClassB.

[wizard_at]

Originariamente inviato da cionci

I getter e i setter sono semplici metodi per accedere rispettivamente in lettura e in scrittura alle variabili membro della classe. E' sempre meglio usarli in quanto sono più resistenti alle modifiche della rappresentazione interna dei dati (basta rinominare una variabile membro per dover rinominare ogni sua chiamata a giro per il codice). Inoltre permettono controlli sui valori impostati dagli utilizzatori della classe in modo da ottenere un utilizzo consistente della stessa.

grazie 1000....si imparano sempre cose nuove