CODEWITHSUNDEEP
c++c++11
bc888
bc888

Reputation: 141

Member variable of subtype of base class in base class

Is there a way to do the following with templates? The following code throws unknown type compile time errors.

I'm trying to create two different types of Application, those that inherit from Application, and those that inherit from Service, which inherits from Application. All Applications have one service called Cron, which will inherit from Service. Applications will be threaded and detached, while Services that derive from Application will be threaded and joined. I broke this down to simplest terms.

#include <iostream>

class Application
{
public:
Service service; //Throws unknown type... Forward decl. will not work either.

};


class Service:public Application
{


};

int main(int argc, const char * argv[])
{

// insert code here...
std::cout << "Hello, World!\n";
return 0;
}

Thanks,

Bruce

Upvotes: 0

Views: 126

Answers (3)

Galik
Galik

Reputation: 48605

It sounds to me like you may benefit from separating the interfaces from the implementations:

struct ApplicationInterface
{
    virtual ~ApplicationInterface() {}

    virtual void do_application_stuff_1() = 0;
    virtual void do_application_stuff_2() = 0;
};

struct ServiceInterface
: public ApplicationInterface
{
    virtual ~ServiceInterface() {}

    virtual void do_service_stuff_1() = 0;
    virtual void do_service_stuff_2() = 0;
};

class CronService
: ServiceInterface
{
public:
    // ApplicationInterface
    virtual void do_application_stuff_1() {}
    virtual void do_application_stuff_2() {}

    // ServiceInterface
    virtual void do_service_stuff_1() {}
    virtual void do_service_stuff_2() {}
};

class Application
: ApplicationInterface
{
protected:
    CronService cron;

public:

    virtual void do_application_stuff_1() {}
    virtual void do_application_stuff_2() {}
};

Upvotes: 0

Rob K
Rob K

Reputation: 8926

I think what you actually want to do is to use a pointer.

class Service;
class Application 
{

     std::shared_ptr<Service> m_service;
};

class Service : public Application
{
};

Upvotes: 0

John Dibling
John Dibling

Reputation: 101446

No, there is no way to do what you want, because what you want to do is nonsense. Hold on, I'll explain.

Service is derived from Application, but Application has a member of type Service.

This is a cyclic dependancy but beyond that, I just don't understand it. Since Service is derived from Application, which has a member of type Service, which is derived from Application, which has a member of type Service... you get the idea. It's like standing in front of a mirror with a mirror and trying to find the end.

Now the question becomes, what are you really trying to do?

In your comments, you said:

I'm trying to create two different types of Application, those that inherit from Application, and those that inherit from Service, which inherits from Application. All Applications have one service called Cron, which will inherit from Service.

There's still a little ambiguity here. How can Application derive from Application?

I suspect that what you're after is having two different concrete instantiations of the class which implements Service. One only implements Service, and the other implements other stuff too.

In that case:

class Service
{
public:
  void Cron();
};

class Application
{
public:
  void OtherStuff();
};

But you also said:

Applications will be threaded and detached, while Services that derive from Application will be threaded and joined.

That sounds like a job for a policy-based design.

class DetatchedPolicy
{
public:
  void StartThread();  // this function would start the thread and detatch
};

class JoinedPolicy
{
public:
  void StartThread();  // this function would start the thread and join
};

template <typename ThreadingPolicy>
class BasicService
:
  public ThreadingPolicy
{
public:
  Service()
  {
    StartThread();
  }
  void Cron();
};

typedef BasicService <JoinedPolicy> Service;
typedef BasicService <DetatchedPolicy> Application;

Upvotes: 5

Related Questions