using abstract class as data type in constructor of dependent class

Question

For a university project we have to create several classes, all depending on the abstract class function.

But while trying to define the class Compose, which has to combine two different functions passed as constructor arguments, I get several problems as shown below.

How exactly can I use my abstract class as a data type without problems in this case?

Abstract Class Function:

class Function{
protected:
    double _a, _b, _c, _m;
public:
    Function(double a, double b, double c, double m): _a(a), _b(b), _c(c), _m(m){}
    virtual double evaluate(double x) =0;
    void print(){ for(double i=0.0; i==1.0; i+=0.1) cout << "Wert: " << i << ", Ergebnis: " << evaluate(i) << endl;}
};

Class Compose:

class Compose:public Function{
private:
    Function *_f1, *_f2;
public:
    Compose(Function & f1, Function & f2):Function(0,0,0,0), _f1(f1), _f2(f2){}
    double evaluate(double x){}
};

Error Messages:

21:54:02 **** Incremental Build of configuration Debug for project Aufgabe_10_1 ****
Info: Internal Builder is used for build
g++ -O0 -g3 -Wall -c -fmessage-length=0 -std=c++11 -o "src\\Aufgabe_10_1.o" "..\\src\\Aufgabe_10_1.cpp" 
..\src\Aufgabe_10_1.cpp: In constructor 'Compose::Compose(Function&, Function&)':
..\src\Aufgabe_10_1.cpp:37:7: error: cannot convert 'Function' to 'Function*' in assignment
   _f1 = f1;
       ^
..\src\Aufgabe_10_1.cpp:38:7: error: cannot convert 'Function' to 'Function*' in assignment
   _f2 = f2;
       ^
..\src\Aufgabe_10_1.cpp: In member function 'virtual double Compose::evaluate(double)':
..\src\Aufgabe_10_1.cpp:40:28: warning: no return statement in function returning non-void [-Wreturn-type]
  double evaluate(double x){}
                            ^

21:54:03 Build Finished (took 423ms)

Answer 1

First problem:

Half of your errors can be reduced to something like this:

Function &a = ...;
Function *b = a;

With what you've shown above, that just doesn't make any sense.

Second problem:

Function doesn't have a constructor that takes zero parameters. So you need to explicitly call a constructor of it in the constructor of Compose. Perhaps something like:

class Compose:public Function{
    private:
        Function *_f1, *_f2;
    public:
        Compose(Function *f1, Function *f2): Function(0,1,2,3), _f1(f1), _f2(f2) {}
        double evaluate(double x) {}
};

Answer 2

Pointers and references can refer to abstract types. Inside your Compose class, you've declared the pointer members _f1 and _f2 which is fine. However, you cannot assign a reference to a pointer so you should change Compose's constructor to also take pointers as arguments.

class Compose : public Function
{

private:

  Function *_f1, *_f2;  // these are pointers

public:

  Compose(Function & f1, Function & f2) : _f1(f1), _f2(f2)
  {    //  ^^^  references here  ^^^      ^^^ problem there ^^^
  }

  // ...
};

This would work:

Compose(Function * f1_ptr, Function * f2_ptr) : _f1(f1_ptr), _f2(f2_ptr)
{    // ^^^  pointers here  ^^^                 ^^^ pointers there ^^^
}

But using raw pointers like this is a problem. Who will be responsible for deleteing them again? Modern C++ avoids such raw pointers wherever possible in favor of so-called smart pointers that do reference counting and automatically delete the pointer when the last reference is destroyed. Therefore, the better design of your class would be like this.

#include <memory>

class Compose : public Function
{

private:

  std::shared_ptr<Function> f1_;
  std::shared_ptr<Function> f2_;

public:

  Compose(std::shared_ptr<Function> f1,
          std::shared_ptr<Function> f2) : f1_ {f1}, f2_ {f2}
  {
  }

  // ...
};

In this case, you don't need to worry about writing a destructor for Compose and it will also be made sure that you'll never dereference an invalid pointer.

You can learn more about resource management using smart pointers here:

• Wikipedia: Resource Acquisition Is Initialization
• cppreference.com: RAII
• Stack Overflow: RAII and smart pointers in C++
• Bjarne Stroustrup: Make Simple Tasks Simple! (starting at 30:30)