more idiomatic. If there would end up being more than one switch
statement, then I would use polymorphism, primarily because it helps
keep code that changes together in the same place.
Virtual function calls require triple indirection pointer and it
requires more execution time like CPU=B9s overheads.
You are prematurely optimizing here. C++'s virtual dispatch system is
very fast. The execution overhead is very minor compared to ease of
understanding/modifying the code.
OK... Please give me your example source code. You can convert my
source code into polymorphism. I am not too sure how you can do it.
Here is your example converted to the standard state pattern:
class Test;
class TestState {
public:
virtual void run(Test* t) { }
virtual int regData() const = 0;
protected:
void changeState(Test* t, TestState* s);
};
class Test
{
friend class TestState;
void changeState(TestState* s) {
state = s;
}
int regData() const { return state->regData(); }
TestState* state;
public:
Test();
~Test();
void Run();
};
void TestState::changeState(Test* t, TestState* s) {
t->changeState(s);
}
class F1 : public TestState {
public:
static TestState* instance();
void run(Test* t);
int regData() const;
};
class F4 : public TestState {
public:
static TestState* instance() {
static F4 state;
return &state;
}
void run(Test* t) {
cout << "F_4()\n";
changeState(t, F1::instance());
}
int regData() const { return 150; }
};
class F3 : public TestState {
public:
static TestState* instance() {
static F3 state;
return &state;
}
void run(Test* t) {
cout << "F_3()\n";
changeState(t, F4::instance());
}
int regData() const { return 100; }
};
class F2 : public TestState {
public:
static TestState* instance() {
static F2 state;
return &state;
}
void run(Test* t) {
cout << "F_2()\n";
changeState(t, F3::instance());
}
int regData() const { return 40; }
};
TestState* F1::instance() {
static F1 state;
return &state;
}
void F1::run(Test* t) {
cout << "F_1()\n";
changeState(t, F2::instance());
}
int F1::regData() const { return 10; }
Test::Test(): state(F1::instance()) {
cout << "Test()\n";
}
Test::~Test() {
cout << "~Test()\n";
}
void Test::Run() { state->run(this); }
int main()
{
Test test;
test.Run();
test.Run();
test.Run();
test.Run();
system("pause");
return 0;
}
Strictly speaking, the state pattern is not appropriate for your example
simply because all your example does is change data, behavior is
unchanged.
The best way to reproduce your output IMHO is something like this:
class Test
{
struct State {
string s;
int i;
State(const char* s, int i):s(s), i(i) { }
};
vector<State> states;
int current;
public:
Test() : current(0) {
cout << "Test()\n";
states.push_back(State("F_1()", 10));
states.push_back(State("F_2()", 40));
states.push_back(State("F_3()", 100));
states.push_back(State("F_4()", 150));
}
~Test() {
cout << "~Test()\n";
}
void Run() {
cout << states[current].s << '\n';
++current;
current &= 3;
}
};- Hide quoted text -
- Show quoted text -- Hide quoted text -
- Show quoted text -
Thanks for your example to the newsgroups. I have seen state pattern
on several websites. I thought--your example (vs rarely used member
function array pointer) should be shown to the public. I appreciate
your assistance. I do more C++ study. Thanks again. :-)