CODEWITHSUNDEEP
c++
selfbg
selfbg

Reputation: 315

Class reference another two classes

I have two classes with some methods with same name. Can I create third class that accept reference from ony of the other two and in the constructor to set obj variable to A or B type?

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

class B
{
    public:
        B();        
        void f();
};

class C
{
    public:
        C(B&);
        C(A&);

    ??? obj;
};

Upvotes: 2

Views: 92

Answers (3)

PeterSW
PeterSW

Reputation: 5281

C++ is a very flexible language and as such provides multiple options for what you are asking for. Each with their own pros and cons.

The first route that comes to mind is to use polymorphism. You have two routes to choose from: static or dynamic polymorphism.

The Static Polymorphic Route

To use static polymorphism (also known as compile-time polymorphism) you should make C a template class:

template <typename T> class C
{
    public:
        C(T&);

        T& obj;
}

The Dynamic Polymorphic Route

To use dynamic (also known as run-time polymorphism) you should provide an interface:

class Fer
{
    public:
        virtual ~Fer() {}

        virtual void f() = 0;
}

Which A and B would implement:

class A : public Fer
{
    public:
        A();        
        void f() overide;
};

class B : public Fer
{
    public:
        B();        
        void f() overide;
};

C would then be like this:

class C
{
    public:
        C(Fer&);

        Fer& obj;
}

The Variant Route

There are various libraries that provide classes that can safely hold arbitrary types.

Some examples of these are:

When using such classes you generally need some means of converting back to the actual type before operating on it.

Upvotes: 2

dlask
dlask

Reputation: 9002

You can have a base class that defines the required interface.

class Base
{
    public:
        Base();
        virtual void f();
};

And you can have derived classes that implement the interface.

class A : public Base
{
    public:
        A();
        virtual void f();
};

class B : public Base
{
    public:
        B();
        virtual void f();
};

The class C then refers to the Base class and can actually accept objects of A or B type.

class C
{
    private:
        Base& base;

    public:
        C(Base& b) : base(b) {}
};

It can be easily used then.

int main()
{
    B b;
    C c(b);
    return 0;
}

Upvotes: 0

songyuanyao
songyuanyao

Reputation: 173044

Maybe you want a template class:

template <typename T>
class C
{
    T& obj;
    public:
        explicit C(T& t) : obj(t) {}
        void f() { obj.f(); }
};

And then:

A a;
B b;
C<A> c1(a);
C<B> c2(b);
c1.f();
c2.f();

Upvotes: 5

Related Questions