C / C++ / MFC

class C1
{
	void fx() { }
	typedef void (C1::*memberFnPtr)();
	void f2()
	{
		memberFnPtr g;
		//void (C1::*g)(); // or like this if you don't want to use a typedef.
		g = &C1::fx;
		(this->*g)();
	}
};

class functor
{
    public:
        void operator()( object &obj )
        {
            obj.A();
        }
};

std::for_each( data.begin(), data.end(), functor() );

std::for_each( data.begin(), data.end(), std::mem_fun_ref( &object::A ) );

std::for_each( data.begin(), data.end(), increase_by_one() );

std::for_each( data.begin(), data.end(), std::mem_fun_ref( &object::increase_by_one) );

class A
{
public:
    void One() {}
};

void (A::*pmfn)() = &A::One;

A obj;
(obj.*pmfn)();

A* ptr = new A;
(A->*pmfn)();

// in context 1
namespace SubscriberContext {

 class Subscriber {
  int mID;

  public:

   bool FileMenu(void) {
    std::out << "FileMenu of object " << mID << " called" << atd::endl;
    return true;
   }

  public:

   Subscriber(int pID) : mID(pID) {}
 };

}

// in some other context where "Subscriber" is not known

#include <functional>
#include <vector>

namespace PublisherContext {

 class Publisher {
  public:
   
   typedef std::tr1::function<bool ()> Delegate;

  private:

   std::vector<Delegate> mSubscribers;

   static void Invoke(Delegate pD) { pD(); }

  public:

   void Connect(Delegate pD) {
    mSubsribers.push_back(pD);
   }
 
   void Disconnect() { 
    mSubscribers.clear();
   }

   void Publish() {
    std::for_each(mSubscribers.begin(), mSubscribers.end(), Publisher::Invoke);
   }
 };

}

// wiring'em up:

int main() {
 using namespace std::tr1;
 using namespace PublisherContext;
 using namespace SubscriberContext;

 Publisher tPub;
 Subscriber tSubs1(1), tSubs2(2), tSubs3(3);

 // connect
 tPub.Connect(bind(mem_fn(&Subscriber::FileMenu), tSubs1));
 tPub.Connect(bind(mem_fn(&Subscriber::FileMenu), tSubs2));
 tPub.Connect(bind(mem_fn(&Subscriber::FileMenu), tSubs3));

 // do work
 tPub.Publish();

 // disconnect
 tPub.Disconnect();
}

Aescleal wrote:

This sort of thing tends to be horses for courses - people who think in OO terms are likely to grab onto using interfaces for everything while people who think in compositional or functional terms will tend to reach for templates.

bool LooseSubscriber() {
  std::out << "LooseSubscriber called" << std::endl;
  return true;
}

int main() {
 Publisher tPub;
 Subscriber tSubs(0);
 // connect to "Subscriber" instance
 tPub.Connect
  (bind(mem_fn(&Subscriber::FileMenu), tSubs));
 // connect to "LooseSubscriber" function
 tPub.Connect
  (LooseSubscriber);
 // ...and if you're on stereoids:
 tPub.Connect
  ([] (void)->bool { 
    std::out << "lambda Subscriber called" << std::endl;
    return true; 
  });
}

Aescleal wrote:

you're preaching to the choir

ganesh_IT wrote:

fstream file("file path", ios_base::binary | ios_base::in);

fstream file("file path", ios_base::binary | ios_base::out);

ganesh_IT wrote:

char buf[] = "BinaryFile"

ganesh_IT wrote:

using namespace std;int main(){ fstream file("file path", ios_base::binary | ios_base::in); char buf[] = "BinaryFile"; file.write(buf, sizeof(buf)); file.close();}