Re: Member Function Pointer vs Virtual Function
Immortal Nephi <Immortal_Nephi@hotmail.com> wrote:
On May 2, 6:22?pm, "Daniel T." <danie...@earthlink.net> wrote:
Immortal Nephi <Immortal_Ne...@hotmail.com> wrote:
Please state your opinion. ?Should you prefer to use member
functions array pointer or switch logic?
If there is only one switch, then I prefer that, primarily because it is
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?s 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;
}
};