Illegal call of non-static member function - C++

I'm trying to implement an interface in C++ but I get stuck on the problem in the title when I try to use some methods within the derived classes.

The idea of the code is as follows.

// ClassHeader.h
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
namespace b
{
struct mainObj
{
virtual ~mainObj(void) {}
virtual double met(const std::vector<double>& vals) const = 0;
};
class Interface
{
public:
Interface(size_t m, const std::vector<double>& tt);
protected:
struct OriginalObj;
size_t _m;
std::vector<double> _tt;
private:
virtual boost::shared_ptr<OriginalObj> make_obj(size_t M, const std::vector<double>& T) const = 0;
virtual const std::vector<double> method1(size_t M, const std::vector<double>& vals) = 0;
};
namespace a {
class Child1 : public Interface
{
public:
// inherit constructor
// using Interface::Interface;
Child1(size_t m, const std::vector<double>& tt);
private:
struct obj1;
boost::shared_ptr<OriginalObj> make_obj(size_t M, const std::vector<double>& T) const override;
const std::vector<double> method1(size_t M, const std::vector<double>& vals) override;
};
} // namespace a
} // namespace b
// ClassHeader.cpp
#include "ClassHeader.h"
namespace b
{
Interface::Interface(size_t m, const std::vector<double>& tt)
:  _m(m), _tt(tt) {}
struct Interface::OriginalObj : public mainObj {
OriginalObj(size_t n, const std::vector<double>& t)
: _n(n),_t(t) {}
size_t _n;
std::vector<double> _t;
};
namespace a {
const std::vector<double> Child1::method1(size_t M, const std::vector<double>& vals)
{
return { static_cast<double>(M), vals[0] };
}
struct Child1::obj1 : public Interface::OriginalObj
{
// inherit constructor
using Interface::OriginalObj::OriginalObj;
Child1* owner;
double met(const std::vector<double>& vals) const override
{
std::vector<double> c = owner->method1(_n, vals);
return c[0];
}
};
Child1::Child1(size_t m, const std::vector<double>& tt)
:Interface(m, tt)
{
obj1 o1(m, tt); //new construction of o1
o1.owner = this; // does this initialize all the members as this?
}
auto Child1::make_obj(size_t M, const std::vector<double>& T) const
-> boost::shared_ptr<OriginalObj>
{
//return boost::make_shared<OriginalObj>(M, T);
return boost::shared_ptr<OriginalObj>{new Child1::obj1(M, T)};
}
} //namespace a
} // namespace b

I know I'm using it without calling it on the object (e.g. c1.method1(...)), but I thought that since it was a class method it was somehow implied. Another issue I'm facing is that I cannot make the method static because it is virtual.

Can anyone please help me understand what I'm doing wrong and how I can solve the problem?

Thanks in advance!

I changed the code to reproduce the error. now I get the exact same error as in my actual code, in the same exact place. Hope this can help you find what I'm doing wrong.

Thanks again

obj1 does not have a default constructor. This is because it inherits from OriginalObj that defines a non-default constructor, rendering the defaulted default constructor non-existant (or deleted):

struct Interface::OriginalObj : public mainObj {
OriginalObj(size_t n, const std::vector<double>& t)
// ...
}
struct Child1::obj1 : public Interface::OriginalObj {
// ...
}

Simply defining OriginalObj() = default; fixes that problem and set you up to the next challenge, being boost::make_shared<OriginalObj>(M, T); tries to construct an object of an abstract class (met() is pure virtual). You need to construct an actual obj1 which can be cast into an OriginalObj:

auto Child1::make_obj(size_t M, const std::vector<double>& T) const
-> boost::shared_ptr<OriginalObj>
{
return boost::shared_ptr<OriginalObj>{new Child1::obj1(M, T)};
}

Full demo: http://coliru.stacked-crooked.com/a/a24e42e600a92736