Použití gettru() z jiné třídy – C / C++ – Fórum – Programujte.com

Ahoj, pomohl by mi někdo s následujícím problémem?

Mám dvě třídy Zpracuj a Eviduj. Ve třídě Zpracuj je funkce provedNastaveni() která má za úkol pomocí settru nastavit hodnotu proměnné setStavNeceho na false. Pokud by však funkce provedNastaveni nebyla (například z mainu) zavolána, stavNeceho by měl zůstat na true – prostě default hodnota (řeším konstruktorem).

Já ale potřebuji s proměnnou stavNeceho pracovat i ve třídě Eviduj. Ovšem pouze tak, že mě zajímá její hodnota – nechci ji měnit. Snažím se tedy uvnitř třídy Eviduj použít getter.

Bohužel při provádění řádku níže, program spadne. Nevíte, kde by mohla být chyba?

bool stavNecehoZeTridyZpracuj = Eviduj::instanceZpracuj->getStavNeceho();

Kód vypadá takto:

Zpracuj.cpp

#include "Zpracuj.h"

Zpracuj::Zpracuj()
{
	// Chci aby kdyz se nezavola setter, byla default hodnota true
	stavNeceho = true;
}

Zpracuj::~Zpracuj()
{
}

// zavolano napr. z mainu (za urcitych podminek)
void Zpracuj::provedNastaveni()
{
	Zpracuj z;
	z.setStavNeceho(false);
}

Zpracuj.h

#ifndef ZPRACUJ_H
#define ZPRACUJ_H

class Zpracuj
{    
    
public:
    static Zpracuj *inst;

public:
    Zpracuj();
    virtual ~Zpracuj();

    bool getStavNeceho() 
   {
	return stavNeceho;
   }
   static Zpracuj *getInstance() 
   {
	if(!inst) inst = new Zpracuj(); 
	return inst;
   }
   
   static void provedNastaveni();

public:
    bool stavNeceho;

private:
    void setStavNeceho(bool stavNeceho_) {stavNeceho = stavNeceho_;}
    
};

#endif // ZPRACUJ_H

Eviduj.cpp

Zpracuj* Eviduj::instanceZpracuj = NULL;

Eviduj::Eviduj()
{
}
 
 Eviduj::metodaKdeChciZjistitHodnotuPromenne()
 {
	 // pri debugovani to zde selze
	 bool stavNecehoZeTridyZpracuj = Eviduj::instanceZpracuj->getStavNeceho();

Eviduj.h

#ifndef EVIDUJ_H
#define EVIDUJ_H

#include "Zpracuj.h"

class Eviduj
{
    public:
        Eviduj();
  
    private:
        static Zpracuj *instanceZpracuj;
};

#endif // EVIDUJ_H

Selže, protože getStavNeceho není statická, takže ji můžeš použít až po zavolání konstruktoru. A pokud bude statická, může přistupovat pouze ke statickým členům.

#2 BDS
Takže musím vytvořit instanci třídy Zpracuj, aby se zavolal konstruktor. Ale pokud místo:

bool stavNecehoZeTridyZpracuj = Eviduj::instanceZpracuj->getStavNeceho();

Použiju:

Zpracuj* z = new Zpracuj();
bool stavNecehoZeTridyZpracuj = z->getStavNeceho();

Program zase spadne. Nebo jsem to špatně pochopil (prosím o trpělivost, jsem začátečník)?

#3 Anonym
Tak se omlouvám za nepřesnost - program nespadne, ale hodnota stavNecehoZeTridyZpracuj je i při přenastavení settrem stále false.
 

možná s tohoto příkladu to pochopíš: 

class Zpracuj
{
 private:
	bool stavNeceho;
 public:
	Zpracuj()
	{
		stavNeceho = false;
	}
	virtual ~Zpracuj();

	bool getStavNeceho()
	{
		return stavNeceho;
	}
 private:
	void setStavNeceho(bool stavNeceho_) { stavNeceho = stavNeceho_; }

};
//varianta 1:
class Eviduj1
{
 private:
	Zpracuj *instanceZpracuj;
 public:
	Eviduj1(Zpracuj * instanceZpracuj)
	{
		this->instanceZpracuj = instanceZpracuj;
	}

	bool metodaKdeChciZjistitHodnotuPromenne()
	{
		return instanceZpracuj->getStavNeceho();
	}
};
//varianta 2:
static class Eviduj2
{	
 public: 
	static bool metodaKdeChciZjistitHodnotuPromenne(Zpracuj * instanceZpracuj)
	{
		return instanceZpracuj->getStavNeceho();
	}
};


int _tmain(int argc, _TCHAR* argv[])
{
	Zpracuj *z = new Zpracuj();

	Eviduj1 *e = new Eviduj1(z);
	bool b1 = e->metodaKdeChciZjistitHodnotuPromenne();
	
	bool b2 = Eviduj2::metodaKdeChciZjistitHodnotuPromenne(z);

	return 0;
}

Myšleno - když změním z.setStavNeceho(false) na z.setStavNeceho(true); Prostě si to za všech okolností drží false.

 

nezapomeň že pokud máš nějakou proměnnou statickou jde ve všech instancích o stejnou proměnnou. Používej static u proměnných pouze tam, kde potřebuješ upravovat nějakou hodnotu společnou pro všechny instance třídy, typický příklad je nastavení nějakého atributu při seřazování položek.

#7 BDS
Super, moc děkuju za pomoc!

Použil jsem variantu č. 2, protože právě potřebuji, aby šlo ve všech instancích o stejnou proměnnou (aspoň se domnívám).

Pokud teď měním hodnotu proměnné stavNeceho, která je v konstruktoru, opravdu dostávám správné výsledky.

Ještě jsem ale narazil na jeden problém. Co když teď budu chtít hodnotu stavNeceho settrem setStavNeceho() ve třídě Zpracuj změnit? Pokud se o to pokusím "nestatickým" způsobem, hodnota se nezmění a statickým způsobem to zase nejde zkompilovat, protože void setStavNeceho(bool stavNeceho_) ... nemá modifikátor "static". Jak to lze nejlépe řešit?


 

#8 Anonym
musí se to změnit. Jestli ne, máš tam něco jiného někde blbě.

Staticky nejde zkompilovat, protože by šlo o pokus o přístup k nestatickému objektu, a to nejde (naopak jo).

class Zpracuj
{
 private:
	bool stavNeceho;
 public:
	Zpracuj()
	{
		stavNeceho = false;
	}
	virtual ~Zpracuj();

	bool getStavNeceho()
	{
		return stavNeceho;
	}
 //toto jsem zapomněl vyhodit -> private:
	void setStavNeceho(bool stavNeceho) 
        { 
         this->stavNeceho = stavNeceho;
        }

};

jinak ty "podtržítka" na konci nebo na začátku názvu funkcí nebo proměnných se myslím mají používat jen za určitých podmínek.. tyto záležitosti moc nemám nastudované.

#9 BDS
Ten setter jsem nastavil na public (pozn.: proč je to nutné, když ho využívám pouze ve třídě Zpracuj a nikde jinde?) a furt je to stejné. Ještě je otázka, jestli ho správně volám. Uvnitř třídy Zpracuj ho v metodě např. abcd() zavolám takto:

Zpracuj zp;
zp.setStavNeceho(true);

#10 Anonym
jo pokud k němu přistupuješ pouze zevnitř, tak může být samozřejmě private

Toto ne!

Zpracuj zp;
zp.setStavNeceho(true);

Jedině takto:

Zpracuj *zp = new Zpracuj();
zp.setStavNeceho(true);

#11 BDS
Tak jsem to předělal a furt stejné :-( Jediné, co mění tu bool hodnotu je ten konstruktor.

Zpracuj *zp = new Zpracuj();
zp.setStavNeceho(true); //true/false žádná změna

Jo ještě teda upřesnění, nemám to takhle: "zp.setStav", ale tak: zp->setStav (nechtělo se to jinak zkompilovat)

#13 Anonym 

Zpracuj *zp = new Zpracuj();
zp->setStavNeceho(true);

jj, to je logické (jsem zapomněl že nejsem v C#), ale nechápu.. pokud děláš něco takového, tak děláš něco jiného než píšeš, protože teď přistupuješ k setStav z venku..

#14 BDS
No přímo v souboru Zpracuj.cpp mám tuto metodu:

void Zpracuj::set()
{
	Zpracuj *zp = new Zpracuj();
	zp->setStavNeceho(true);
}

Celou tu metodu set() pak volám z mainu jako

Zpracuj::set();

A v tom hlavičkovém Zpracuj.h je ta metoda deklarována takto:

public:
	static void set();

#15 Anonym
no vidíš..

malý test: 

class Zpracuj
{
private:
	bool stavNeceho;
public:
	Zpracuj()
	{
		setStavNeceho(false);
	}

	bool getStavNeceho()
	{
		return stavNeceho;
	}

   void setStavNeceho(bool stavNeceho)
	{
		this->stavNeceho = stavNeceho;
	}

   void vypis()
   {
	   if (stavNeceho)printf("je ");
	   else printf("neni ");
   }

};


int _tmain(int argc, _TCHAR* argv[])
{
	Zpracuj *zp = new Zpracuj();
	zp->setStavNeceho(true);
	zp->vypis();
	zp->setStavNeceho(false);
	zp->vypis();
	zp->setStavNeceho(true);
	zp->vypis();

	delete zp;

	getchar();
	return 0;
}

//výpis programu: je neni je

na co vytváříš novou instanci v instanci?

stačí přece:

void Zpracuj::set()
{
 setStavNeceho(true);
}

a proč to máš zase jako static?

#16 BDS
Použil jsem ten tvůj kód a výpis mi funguje stejně. V té třídě Eviduj, resp. Eviduj2 se mi ale hodnota proměnné stále drží na false.

//varianta 2:
static class Eviduj2
{	
 public: 
	static bool metodaKdeChciZjistitHodnotuPromenne(Zpracuj * instanceZpracuj)
	{
		return instanceZpracuj->getStavNeceho();
	}
};

S tím, že tu metodu kde chci zjistit hodnotu proměnné zavolám takhle:

void Eviduj::Abcdef()
{
    Zpracuj *zp = new Zpracuj();
    bool b = Eviduj::metodaKdeChciZjistitHodnotuPromenne(zp);

    // vypis b = false

}

#17 Anonym
nebudu nijak řešit toto "void Eviduj::Abcdef()", dnes končím, ale pokud uděláš toto: 

Zpracuj *zp = new Zpracuj();
zp->setStavNeceho(true)
bool b = Eviduj::metodaKdeChciZjistitHodnotuPromenne(zp);
//bool b je ted určitě true

tady to máš celé:

class Zpracuj
{
private:
	bool stavNeceho;
public:
	Zpracuj()
	{
		stavNeceho = false;
	}

	bool getStavNeceho()
	{
		return stavNeceho;
	}
	void setStavNeceho(bool stavNeceho_) { stavNeceho = stavNeceho_; }

};

static class Eviduj2
{
public:
	static bool metodaKdeChciZjistitHodnotuPromenne(Zpracuj * instanceZpracuj)
	{
		return instanceZpracuj->getStavNeceho();
	}
};


int _tmain(int argc, _TCHAR* argv[])
{
	Zpracuj *zp = new Zpracuj();
	zp->setStavNeceho(true);
	bool b = Eviduj2::metodaKdeChciZjistitHodnotuPromenne(zp);

	if (b)printf("ok");

	delete zp;

	getchar();
	return 0;
}

#18 BDS 

Načo to robiť jednoducho keď to ide spraviť zložito...

static class Eviduj2
{
public:
	static bool metodaKdeChciZjistitHodnotuPromenne(Zpracuj * instanceZpracuj)
	{
		return instanceZpracuj->getStavNeceho();
	}
};

Jednoduchá verzia:

bool metodaKdeChciZjistitHodnotuPromenne(Zpracuj* instanceZpracuj){
	return instanceZpracuj->getStavNeceho();
}

//alebo rovno použiť:

instanceZpracuj->getStavNeceho();

Celý ten návrh je dosť divný, Možno by úplne stačila jedna trieda kde budú dáta, prípadne primitívna štruktúra a k tomu 2 funkcie/metódy na serializáciu a deserializáciu...

#19 vitamin
nevím on to tak chtěl, zkoumá komunikaci tříd. Smysl celého návrhu je z jakéhokoliv pohledu mimo všeho co si dokážu představit.

#20 BDS
Někdo mu asi nakecal, že je nutné rozdělit třídu do dvou - na část datovou a část výkonnou. Už jsem se s takovou kravinou setkal.