CODEWITHSUNDEEP
c++
nww04
nww04

Reputation: 1857

How to write java like argument-level implementation of interface in C++?

One of the nice things in Java is implementing interface. For example consider the following snippet:

interface SimpleInterface()
{
public: void doThis();
}

...
SimpleInterface simple = new SimpleInterface()
{
@Override public doThis(){ /**Do something here*/}
}

The only way I could see this being done is through Lambda in C++ or passing an instance of function<> to a class. But I am actually checking if this is possible somehow? I have classes which implements a particular interface and these interfaces just contain 1-2 methods. I can't write a new file for it or add a method to a class which accepts a function<> or lambda so that it can determine on what to do. Is this strictly C++ limitation? Will it ever be supported?

Somehow, I wanted to write something like this:

thisClass.setAction(int i , new SimpleInterface()
{
protected:
virtual void doThis(){}
});

One thing though is that I haven't check the latest spec for C++14 and I wanted to know if this is possible somehow.

Thank you!

Upvotes: 1

Views: 130

Answers (4)

Puppy
Puppy

Reputation: 147018

Will it ever be supported?

You mean, will the language designers ever add a dirty hack where the only reason it ever existed in one language was because those designers were too stupid to add the feature they actually needed?

Not in this specific instance.

You can create a derived class that derives from it and then uses a lambda, and then use that at your various call sites. But you'd still need to create one converter for each interface.

struct FunctionalInterfaceImpl : SimpleInterface {
    FunctionalInterfaceImpl(std::function<void()> f)
        : func(f) {}
    std::function<void()> func;
    void doThis() { func(); }
};

Upvotes: 6

Prikso NAI
Prikso NAI

Reputation: 2652

This is indeed a "limitation" of C++ (and C#, as I was doing some research some time ago). Anonymous java classes are one of its unique features.

The closest way you can emulate this is with function objects and/or local types. C++11 and later offers lambdas which are semantic sugar of those two things, for this reason, and saves us a lot of writing. Thank goodness for that, before c++11 one had to define a type for every little thing.

Please note that for interfaces that are made up of a single method, then function objects/lambdas/delegates(C#) are actually a cleaner approach. Java uses interfaces for this case as a "limitation" of its own. It would be considered a Java-ism to use single-method interfaces as callbacks in C++.

Local types are actually a pretty good approximation, the only drawback being that you are forced to name the types (see edit) (a tiresome obligation, which one takes over when using static languages of the C family).

You don't need to allocate an object with new to use it polymorphically. It can be a stack object, which you pass by reference (or pointer, for extra anachronism). For instance:

struct This {};

struct That {};

class Handler {
  public:
    virtual ~Handler ();
    virtual void handle (This) = 0;
    virtual void handle (That) = 0;
};

class Dispatcher {
    Handler&    handler;
  public:
    Dispatcher (Handler& handler): handler(handler) { }

    template <typename T>
    void dispatch (T&& obj) { handler.handle(std::forward<T>(obj)); }
};

void f ()
{
    struct: public Handler {
        void handle (This) override { }
        void handle (That) override { }
    } handler;
    Dispatcher dispatcher { handler };
    dispatcher.dispatch(This {});
    dispatcher.dispatch(That {});
}

Also note the override specifier offered by c++11, which has more or less the same purpose as the @Override annotation (generate a compile error in case this member function (method) does not actually override anything).

I have never heard about this feature being supported or even discussed, and I personally don't see it even being considered as a feature in C++ community.

EDIT right after finishing this post, I realised that there is no need to name local types (naturally), so the example becomes even more java-friendly. The only difference being that you cannot define a new type within an expression. I have updated the example accordingly.

Upvotes: 1

Angew is no longer proud of SO
Angew is no longer proud of SO

Reputation: 171167

You seem to think each class needs a separate .h and .cpp file. C++ allows you to define a class at any scope, including local to a function:

void foo() {
  struct SimpleInterfaceImpl : SimpleInterface
  {
  protected:
    void doThis() override {}
  };

  thisClass.setAction(int i , new SimpleInterfaceImpl());
}

Of course, you have a naked new in there which is probably a bad idea. In real code, you'd want to allocate the instance locally, or use a smart pointer.

Upvotes: 2

user3427457
user3427457

Reputation: 162

In c++ interfaces are classes which has pure virtual functions in them, etc 

class Foo{
   virtual Function() = 0;
};

Every single class that inherits this class must implement this function.

Upvotes: -1

Related Questions