Portál AbcLinuxu, 4. července 2025 12:19
#include <string>
#include <iostream>
class Base {
public:
std::string x;
int y;
Base(std::string x_, int y_): x(x_), y(y_) {}
Base(Base &&b): x(std::move(b.x)), y(b.y) {}
virtual ~Base() {}
virtual void do_something() = 0;
virtual void turn_to_a() {}
};
class B;
class A: public Base {
public:
A(B &&b);
A(std::string x_, int y_): Base(x_, y_) {}
void do_something() override
{
std::cout << "I am 'A'. x = " << x << ", y = " << y << "\n";
}
};
class B: public Base {
public:
B(std::string x_, int y_): Base(x_, y_) {}
void do_something() override
{
std::cout << "I am 'B'. x = " << x << ", y = " << y << "\n";
}
void turn_to_a() override
{
static_assert(sizeof(A) == sizeof(B), "must be the same size");
B tmp(std::move(*this));
this->B::~B();
new (this) A(std::move(tmp));
}
};
A::A(B &&b): Base(std::move(b)) {}
int main()
{
Base *b = new B("life, universe and everything", 42);
b->do_something();
b->turn_to_a();
b->do_something();
delete b;
}
Řešení dotazu:
9.10.2012 20:06
union?
bool is_a;. A potom v kazdy metode testoval jestli je flag nastaveny, ale prijde me ze mit to oddeleny je o neco cistsi.
.
Dejme tomu ze mam 2 tridy - A a B. Obe dedi z tridy Base. Nepridavaji zadne promenne, jen predefinuji virtualni funkce. Program nacita data a vetsinou z nich chce vytvorit tridu B. Obcas ale A a problem je ze tuto informaci se dozvi az pozdeji. Kdyz se dozvi ze vlastne potrebuje A tak nechci aby musel alokovat novou pamet, ani aby musel zpetne menit pointery ktere uz ukazuji na B.Začalo to hezky, skoro jako v pohádce: Žily byly dvě sestry, jedna staříkova, druhá stařenčina ... ... ale zápletka na sebe nenechala dlouho čekat. Pokud program chce "většinou" vytvořit třídu B, ale někdy později ji chce vyměnit za A, tak najednou se po nás chce zajistit dynamické chování ve statickém světě dědičnosti tříd. Prostě z jezevčíka mávnutím kouzelné hůlky udělat dobrmana. Vždyť je to přeci také pes. Použití operátoru new s umístěním je ale stejné jako nahánění jezevčíka s chirurgickým skalpelem v ruce. Když se na to podívám z druhé strany, tak vlastně nepotřebuji předělávat jezevčíka na dobrmana, ale chci jen naučit psa kousat jako dobrman, aby mi nikdo nechodil po dvorku. Pokud nejsem psí zubař, tak mohu tedy skalpel s klidem zahodit
.
Na všechno mi stačí jedna hlavní třída a to případné "kousání" si zajistíme až podle situace.
#include <iostream>
enum StrategyType
{
A,
B
};
class Strategy
{
protected:
std::string* x;
int* y;
public:
void setOptions(std::string* _x, int* _y) { x = _x; y = _y; }
virtual void doSomething() = 0;
};
class StrategyA : public Strategy
{
virtual void doSomething()
{
std::cout << "I am 'A'. x = " << *x << ", y = " << *y << std::endl;
}
};
class StrategyB : public Strategy
{
virtual void doSomething()
{
std::cout << "I am 'B'. x = " << *x << ", y = " << *y << std::endl;
}
};
class Base
{
private:
std::string x;
int y;
Strategy* strategy;
public:
Base(std::string x_, int y_): x(x_), y(y_), strategy(NULL) {}
~Base() { delete strategy; }
void doSomething()
{
strategy->doSomething();
}
void setStrategy(StrategyType type)
{
if (strategy)
delete strategy;
if (type == A)
strategy = new StrategyA();
else if (type == B)
strategy = new StrategyB();
strategy->setOptions(&x, &y);
}
};
int main()
{
Base base("life, universe and everything", 42);
base.setStrategy(B);
base.doSomething();
// ...
base.setStrategy(A);
base.doSomething();
return 0;
}
Oproti zadání je možné měnit strategie nejen z B na A, ale i zpět a navíc opakovaně.
template<typename T>
class Wrap
{
public:
T* new_() { return new(this) T();}
void delete_() { ((T*)this)->~T(); }
unsigned char data[sizeof(T)];
};
class Base
{
public:
Base() {}
virtual ~Base() {}
virtual int getType() const = 0;
int a;
int b;
};
class A : public Base
{
public:
A() {}
virtual ~A() {}
virtual int getType() const { return 1; }
};
class B : public Base
{
public:
B() {}
virtual ~B() {}
virtual int getType() const { return 2; }
};
union Union
{
template<typename T>
T* as() { return (T*)this; }
Wrap<A> a;
Wrap<B> b;
};
int main(int argc, char* argv[])
{
Union u;
u.a.new_();
printf("%d\n", u.as<Base>()->getType());
u.a.delete_();
u.b.new_();
printf("%d\n", u.as<Base>()->getType());
u.b.delete_();
return 0;
}
Tiskni
Sdílej:
ISSN 1214-1267, (c) 1999-2007 Stickfish s.r.o.