Member and static functions while assignment

[Alex Vinokur]

I have the following problem.

class Base
{
public:
void (*pfunc) (int) = 0;
};

class Derived : public Base
{
public:
void (*pfunc) (int a)
{
// Stuff
}
};
class Foo
{
private:
void (*pf) (int);
public:
Foo (Base* ptr)
{
pf = ptr->pfunc; // Error, because pfunc is a member function,
not static
}
};

Is there any way to do something like "pf = ptr->pfunc"?
Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

[mlimber]

Alex Vinokur wrote:

I have the following problem.

class Base
{
public:
void (*pfunc) (int) = 0;
This line won't compile. It's neither a static integral constant nor a
pure virtual function, but you seem to have mixed the syntax for the
two.
};

class Derived : public Base
{
public:
void (*pfunc) (int a)
You can't define a body for a pointer to a function. Please see the FAQ
for this group on how to post code:

http://www.parashift.com/c++-faq-lit...t.html#faq-5.8
{
// Stuff
}
};
class Foo
{
private:
void (*pf) (int);
public:
Foo (Base* ptr)
{
pf = ptr->pfunc; // Error, because pfunc is a member function,
not static
You have a lot bigger problems than that!
}
};

Is there any way to do something like "pf = ptr->pfunc"?

Yes. See the FAQs:

http://www.parashift.com/c++-faq-lit...o-members.html

Cheers! --M

[Victor Bazarov]

Alex Vinokur wrote:

I have the following problem.

class Base
{
public:
void (*pfunc) (int) = 0;
A pointer to a function taking an int and returning void.
};

class Derived : public Base
{
public:
void (*pfunc) (int a)
Huh? Another pointer to a function...
{
// Stuff
Are you trying to define a body after declaring a pointer to a function?
}
};
class Foo
{
private:
void (*pf) (int);
OK, a pointer to a function.
public:
Foo (Base* ptr)
{
pf = ptr->pfunc; // Error, because pfunc is a member function,
not static
}
};

Is there any way to do something like "pf = ptr->pfunc"?

What are you trying to accomplish here? Perhaps read about the template
'std::binder_1s t', you can do something like

pf = std::bind1st(&B ase::pfunc, ptr);

although it is a bit convoluted, but should get you what you want, IIUYC.

Next time try to show what you intend to do with 'pf'.

V

[Alex Vinokur]

"mlimber" <ml*****@gmail. com> wrote in message
news:11******** **************@ o13g2000cwo.goo glegroups.com.. .

Alex Vinokur wrote:

I have the following problem.

class Base
{
public:
void (*pfunc) (int) = 0;

This line won't compile. It's neither a static integral constant nor a
pure virtual function, but you seem to have mixed the syntax for the
two.

[snip]

My first message was unlucky. Please ignore it.

Here is problematic program.
====== foo1.cpp ======
struct Base
{
virtual void func (int) = 0;
};

struct Derived : public Base
{
void func (int)
{
// Stuff
}
};

struct Foo
{
void (*pfunc) (int);
Base* p_;

Foo (Base* p) : p_ (p) {}

void doit ()
{

// Here is what I want to reach
pfunc = p_->func;

// ------------------------
// g++ 4.0.1 produces the following error message:
// ............... .........
// error: argument of type 'void (Base::)(int)'
// does not match 'void (*)(int)
// ............... .........
// because func() is _member_ (not static) function
// ------------------------
}
};
int main ()
{
Base* p = new Derived;
Foo foo (p);
delete p;

return 0;
}
=============== =======
Here is a _partial_ solution of the problem.
====== foo2.cpp ======
struct Base
{
virtual void func (int) = 0;
};

struct Derived : public Base
{
void func (int)
{
// Stuff
}
};

struct Foo
{
void (*pfunc) (int);
static Base* p_s;

Foo (Base* p) { p_s = p; }

static void wrapper(int a)
{
p_s->func (a);
}

void doit ()
{
pfunc = wrapper;
}
};
Base* Foo::p_s = 0;
int main ()
{
Base* p = new Derived;
Foo foo (p);
delete p;

return 0;
}

=============== =======
--
Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

[Victor Bazarov]

Alex Vinokur wrote:

"mlimber" <ml*****@gmail. com> wrote in message
news:11******** **************@ o13g2000cwo.goo glegroups.com.. .

Alex Vinokur wrote:

I have the following problem.

class Base
{
public:
void (*pfunc) (int) = 0;
This line won't compile. It's neither a static integral constant nor a
pure virtual function, but you seem to have mixed the syntax for the
two.

[snip]

My first message was unlucky. Please ignore it.

Here is problematic program.
====== foo1.cpp ======
struct Base
{
virtual void func (int) = 0;

Add:

virtual ~Base() {}
};

struct Derived : public Base
{
void func (int)
{
// Stuff
}
};

struct Foo
{
void (*pfunc) (int);
Base* p_;

Foo (Base* p) : p_ (p) {}

void doit ()
{

// Here is what I want to reach
pfunc = p_->func;
And then what? How do you intend to use 'pfunc'?

// ------------------------
// g++ 4.0.1 produces the following error message:
// ............... .........
// error: argument of type 'void (Base::)(int)'
// does not match 'void (*)(int)
// ............... .........
// because func() is _member_ (not static) function
// ------------------------
}
};
int main ()
{
Base* p = new Derived;
Foo foo (p);
delete p;

return 0;
}
=============== =======
Here is a _partial_ solution of the problem.
Which problem?
====== foo2.cpp ======
struct Base
{
virtual void func (int) = 0;
};

struct Derived : public Base
{
void func (int)
{
// Stuff
}
};

struct Foo
{
void (*pfunc) (int);
static Base* p_s;

Foo (Base* p) { p_s = p; }

static void wrapper(int a)
{
p_s->func (a);
}

void doit ()
{
pfunc = wrapper;
}
};
Base* Foo::p_s = 0;
int main ()
{
Base* p = new Derived;
Foo foo (p);
delete p;

return 0;
}

=============== =======

Study this:

////////////////////////////////////
struct Base
{
virtual void func (int) = 0;
virtual ~Base() {}
};

struct Derived : public Base
{
void func(int)
{
// Stuff
}
};

struct Foo
{
void (Base::*pfunc) (int);

Foo (void (Base::*pf) (int)) : pfunc(pf) {}

void doit(Base* p_)
{
(p_->*pfunc)(42);
}
};
int main ()
{
Base* p = new Derived;
Foo foo(&Base::func );

foo.doit(p);

delete p;
}
/////////////////////////////////////////

V

[mlimber]

Alex Vinokur wrote:

My first message was unlucky. Please ignore it.

Here is problematic program.
====== foo1.cpp ======
struct Base
{
virtual void func (int) = 0;
};

struct Derived : public Base
{
void func (int)
{
// Stuff
}
};

struct Foo
{
void (*pfunc) (int);
Base* p_;

Foo (Base* p) : p_ (p) {}

void doit ()
{

// Here is what I want to reach
pfunc = p_->func;

// ------------------------
// g++ 4.0.1 produces the following error message:
// ............... .........
// error: argument of type 'void (Base::)(int)'
// does not match 'void (*)(int)
// ............... .........
// because func() is _member_ (not static) function
// ------------------------
}
};

Ok, now you've posed the problem correctly, and in order to find the
solution, all you need to do is read the FAQs to which I previously
referred you:

http://www.parashift.com/c++-faq-lit...o-members.html

[snip] Here is a _partial_ solution of the problem.
====== foo2.cpp ======
struct Base
{
virtual void func (int) = 0;
};

struct Derived : public Base
{
void func (int)
{
// Stuff
}
};

struct Foo
{
void (*pfunc) (int);
static Base* p_s;

Foo (Base* p) { p_s = p; }

static void wrapper(int a)
{
p_s->func (a);
}

void doit ()
{
pfunc = wrapper;
}
};
Base* Foo::p_s = 0;
int main ()
{
Base* p = new Derived;
Foo foo (p);
delete p;

return 0;
}

This is not a good solution. It is not necessary to resort to static
members and methods. See the FAQs.

Cheers! --M

[Alex Vinokur]

Victor Bazarov wrote:
[snip]

Study this:

////////////////////////////////////
struct Base
{
virtual void func (int) = 0;
virtual ~Base() {}
};

struct Derived : public Base
{
void func(int)
{
// Stuff
}
};

struct Foo
{ --------------------------------- void (Base::*pfunc) (int); But here I have to use
void (*pfunc) (int);
---------------------------------
Foo (void (Base::*pf) (int)) : pfunc(pf) {}

void doit(Base* p_)
{
(p_->*pfunc)(42);
}
};
int main ()
{
Base* p = new Derived;
Foo foo(&Base::func );

foo.doit(p);

delete p;
}
/////////////////////////////////////////

V

Alex Vinokur

[Alf P. Steinbach]

* Alex Vinokur:

I have to use
void (*pfunc) (int);

[to call a member function]

If you have any leeway at all, consider using a functor object instead. That
can encapsulate an ordinary static function, or a member function bound to an
object (sometimes called a _closure_ or a _delegate_), or whatever. See the
FAQ items at the end of the FAQ page that "mlimber" pointed to.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Alex Vinokur]

Alf P. Steinbach wrote:

* Alex Vinokur:

I have to use
void (*pfunc) (int);

[to call a member function]

If you have any leeway at all, consider using a functor object instead. That
can encapsulate an ordinary static function, or a member function bound to an
object (sometimes called a _closure_ or a _delegate_), or whatever. See the
FAQ items at the end of the FAQ page that "mlimber" pointed to.

[snip]

Thanks.

I saw the FAQ.

But it seems that it doesn't solve my problem.
Here my situation.

struct BaseBar
{
// Stuff: Data members
virtual void callback (int) = 0;
virtual ~BaseBar() {}
};

struct Bar1 : public BaseBar
{
// Stuff: Data members
void callback (int)
{
// Stuff
}
};
struct Bar2 : public BaseBar
{
// Stuff: Data members
void callback (int)
{
// Stuff
}
};

struct Config
{
// Stuff: Data members
void (*the_callback) (int); // We can't change this prototype

};

struct Foo
{
// Stuff: Data members
Config config_;
Foo (BaseBar* ptr_i)
{
// Stuff
// Here I have to do what is impossible to do:
// -----------------------
// config_.the_cal lback = ptr_i->callback;
// -----------------------
}
};

int main ()
{
Bar1 bar1;
Bar2 bar2;

Foo foo1 (&bar1);
Foo foo2 (&bar2);
Foo foo3 (&bar1);

return 0;
}
The approach from
http://www.parashift.com/c++-faq-lit....html#faq-33.2
doesn't help here because we have several Bar-ojects created.
Alex Vinokur

[Alf P. Steinbach]

* Alex Vinokur:

void (*the_callback) (int); // We can't change this prototype
The approach from
http://www.parashift.com/c++-faq-lit....html#faq-33.2
doesn't help here because we have several Bar-ojects created.

If the callback is only called during initialization I don't see why not.

Otherwise, if you can specify the int argument to the callback, then use a
std::map as the global, not just a single pointer, and the int argument as key
to the map.

Otherwise, if you can't specify the argument then it seems the API you're
using supports only a single callback which can be called at any time, and you
then have to decide whether you want just a single object to receive the call
or whether to distribute it to all objects, or what.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?