Is it possible to instantiate an interface without pointers?

Question

My case is the following: In my larger program I want to make an interface to grab frames from a imagesource. However, in the program I do not know in advance whether I want to grab frames from a camera or from a video file. But I would like to have one interface that handles video files and camera frames as identical. This in total is is taking much code to accomplish, thus I'll present a very short example.

this is the example of the interface:

class Input {

    public :

        virtual void
        get_frame() = 0;
};

This is a derived class that should grab frames from a camera.

class CameraInput: public Input {

    public :
        void get_frame();
};

This is the class that should open a videofile and grab frames from the file.

class VideoInput: public Input {

    public :

        void get_frame();

};

Here are the definitions of the get_frame from the Input derived classes. As you can see they "produce" a different type of video frame.

void
CameraInput::get_frame(){
    std::cout << "camera-frame" << std::endl;
};

void
VideoInput::get_frame() {
    std::cout << "video-frame" << std::endl;
};

This it the code that instantiates an object of type CameraInput or VideoInput.

Edit shared pointer added

typedef enum { VIDEO, CAMERA } input_type ;
std::shared_ptr<Input> framegrabber;
/*Does this have to be a pointer?*/

/*In my program I don't know this in advance.*/
input_type my_input = CAMERA;

switch ( my_input ){
    case CAMERA:
        framegrabber = std::shared_ptr<Input>(new CameraInput);
        break;
    case VIDEO:
        framegrabber = std::shared_ptr<Input>(new VideoInput);
        break;
    default:
        /*error handling here*/
        break;
};

framegrabber->get_frame();

On stackoverflow I read many times in c++ answers, that one should never use pointers unless one really, really needs to. This is where my question comes from, is it possible and better to rewite the code above without using a Input* or is this one of the case where it is mandatory to use pointers?

kind regards,

@PlasmaHH ok agreed I'll do that, but it doesn't answer my question. — hetepeperfan, Jul 19 '13 at 13:04

SigTerm · Accepted Answer · 2013-07-19T13:51:51.527

On stackoverflow I read many times in c++ answers, that one should never use pointers unless one really, really needs to.

When you read any advice, you should try to understand WHY this advice is given. If there's no good reason behind advice, there's no need to follow that advice.

Trying to eliminate all pointers from your program just because somebody told you "pointers are bad" is not a good idea.

Experienced programmers tell you to avoid raw pointers, because pointers mean manual memory management, which is error prone (forget to delete something == memory leak), plus you have to be aware of rule of three.
I also have impression that inexperienced programmers frequently give the same advice because they simply do not understand pointers completely (or are afraid of them?).

You CAN use references, but because you can't copy/reassign references that'll be less useful. Example:

#include <iostream>

class A{
public:
    virtual int getVal() const = 0;
    virtual ~A(){}
};

class B: public A{
public:
    virtual int getVal() const { return 2; };
};

class C: public A{
public:
    virtual int getVal() const { return 3; };
};

class D{
public:
    const A& getInterface(bool which) const{
        if (which)
            return c;
        return b;
    }
protected:
    B b;
    C c;
};

int main(int argc, char** argv){
    D d;
    std::cout << d.getInterface(true).getVal() << std::endl;
    std::cout << d.getInterface(false).getVal() << std::endl;
    return 0;
}

As you can see, to return object by reference, you'll need to create it somewhere, and store it. If you want to "kill all pointers", then you'll need to create this object as a member variable of bigger class (or as a global variable).

With pointer, you could simply return shared_ptr<A>.

In your code, the better idea would be to use smart pointer class instead of raw pointers. That'll eliminate need for manual delete/memory management.

it possible and better to rewite the code above without using a Input*

Yes, it is possible, but there's no reason to do it, and this is (IMO) NOT better. My example illustrates how you could do it. Without pointers(of any kind - smart or raw) you'll also have to store BOTH CameraInput and VideoInput somewhere, while with pointers you can create them on demand.

Thanks for the elaborate answer. Your answer also explained to me why (smart) pointer approach is better here, since I wouldn't want to create an interface that tries to load both a video from file and retrieve retrieve the frames from a camera. — hetepeperfan, Jul 19 '13 at 14:03
Raw pointers are perfectly fine - just assume by default that they don't own anything and are simply a reseatable and nullable reference, because that's the only thing they should be used for now (well, with the odd exception for low-level building blocks). — Xeo, Jul 20 '13 at 11:17

score 0 · Answer 2 · edited May 23 '17 at 11:49

0

You could use a smart pointer (e.g. std::unique_ptr or std::shared_ptr) instead of the raw pointers.
If you want polymorphism, you must use pointers or references. There are far more details than you really want here

edited May 23 '17 at 11:49

Community

1
1

answered Jul 19 '13 at 13:07

doctorlove

18,872
2
46
62

1

I would consider replacing *unqiue_ptr* and *sahred_ptr* with something else. – Markus Meskanen Jul 19 '13 at 13:12
Could you give an example how this could be done with a variable by reference? – hetepeperfan Jul 19 '13 at 13:28
@MarkusMeskanen in the last paragraph I'm explaining why I asked this question. I'm not saying pointer are wrong no matter what. – hetepeperfan Jul 19 '13 at 13:39

Is it possible to instantiate an interface without pointers?

2 Answers2