Can I instantiate a member class template with member variables?

user_13060365 0
Viewed 61
class NDArray{

    private:
        Context ctx_;
        typeFlag dtype_;
        std::vector<size_t> shape_;
        std::shared_ptr<TBlob<dtype_, ctx_.dev_type_, ctx_.dev_id_> > data_;

    public:
        // constructor
        NDArray(); 
        NDArray(const NDArray &obj);
        explicit NDArray(const size_t size);

I want to instantiate data_ member after the constructor, where I initialize the ctx_ and dtype_ member

inline NDArray::NDArray(): ctx_(Context()), shape_{0}, dtype_(typeFlag::kFloat32), {}
inline NDArray::NDArray(const NDArray &obj): ctx_(obj.ctx_), shape_(obj.shape_), dtype_(obj.dtype_), data_(obj.data_){}

Then I got errors:

NDArray.hpp:18:31: error: invalid use of non-static data member ‘mxnet::NDArray::dtype_’
         std::shared_ptr<TBlob<dtype_, ctx_.dev_type_, ctx_.dev_id_> data_;
                               ^
NDArray.hpp:16:18: note: declared here
         typeFlag dtype_;

What can I do to achieve my goal? Could you plz help me

EDIT

template<typeFlag dtype, Context::DeviceType ctx_type, int ctx_id>
class TBlob{
    friend class NDArray;

    public:
        TBlob();
        TBlob(const TBlob<dtype, ctx_type, ctx_id> &obj);
        explicit TBlob(const size_t &size);
        explicit TBlob(const std::vector<size_t> &shape);
        TBlob(const float *data, const size_t size);
        TBlob(const float *data, const std::vector<size_t> shape);
        TBlob(const uint8_t *data, const size_t size);
        TBlob(const uint8_t *data, const std::vector<size_t> shape);
        ~TBlob();

    private:
        void *dptr_;
        std::vector<size_t> shape_;
};

template<typeFlag dtype, Context::DeviceType ctx_type, int ctx_id>
inline TBlob<dtype, ctx_type, ctx_id>::TBlob(): dptr_(nullptr), shape_{0} {}

template<typeFlag dtype, Context::DeviceType ctx_type, int ctx_id>
inline TBlob<dtype, ctx_type, ctx_id>::TBlob(const TBlob<dtype, ctx_type, ctx_id> &obj): dptr_(obj.dptr_), shape_(obj.shape_) {}
templates c++
1 Answers

This is the closest thing I can think of to what you want, but I don't know if it will be useful to you. Note there is a slight overhead due to virtual methods. I used a more simple example but it should be more or less equivalent.

#include <memory>
#include <utility>
#include <iostream>

// Base interface class for the templated type
class TemplInterface
{
public:
    // Templated class (pure?) virtual method declarations
    // (parameter and return types cannot depend on template values)
    virtual void print_value() const = 0;
};

// Actual templated type
template<int i>
class Templ : public TemplInterface
{
public:
    // Templated class implementation
    virtual void print_value() const
    {
        std::cout << "Value: " << i << std::endl;
    }
};

// Class containing the templated type
class Outer
{
private:
    // Member pointer to non-template base type
    std::shared_ptr<TemplInterface> _templ;
    // Class constructor is private
    Outer(std::shared_ptr<TemplInterface> templ) : _templ(std::move(templ)) {}
public:
    // Factory function
    template<int i>
    static Outer make()
    {
        return Outer(std::make_shared<Templ<i>>());
    }
    void print_templ() const
    {
        _templ->print_value();
    }
};

int main()
{
    Outer a = Outer::make<3>();
    a.print_templ();
    return 0;
}

Output:

Value: 3
user_17827920
Related