如何从子类的构造函数初始化父类的私有成员

Question

I have an AbstractClass that is inherited by two classes SubClass1, BaseClass. Each BaseClass keeps two sets of vectors of AbstractClasses which it uses calculate an id. BaseClass is inherited by SubClass2 which wants to set vectors of BaseClass, is there any way to initialize BaseClass without going through the initalizer list? If I do have to pass in the vectors in a special way because I get an error

'std::unique_ptr<AbstractClass,std::default_delete<_Ty>>::unique_ptr(const std::unique_ptr<_Ty,std::default_delete<_Ty>> &)': attempting to reference a deleted function

"project.h"

class AbstractClass {
    virtual int getId() = 0;
};

class BaseClass: public AbstractClass {
public:
    BaseClass(std::vector<std::unique_ptr<AbstractClass>> v1, std::vector<std::unique_ptr<AbstractClass>> v2)
    : vec1_(v1), vec2_(v2){
    }
    std::vector<std::unique_ptr<AbstractClass>> getVec1() {
        return vec1_;
    }
    std::vector<std::unique_ptr<AbstractClass>> getVec2() {
        return vec2_;
    }
private:
    std::vector<std::unique_ptr<AbstractClass>> vec1_;
    std::vector<std::unique_ptr<AbstractClass>> vec2_;
};

class SubClass1 : public AbstractClass {
public:
    int getId() override {
        return 1;
    }
};

class SubClass2 : public BaseClass {
public:
    SubClass2() {
        std::vector<std::unique_ptr<AbstractClass>> vec1;
        std::vector<std::unique_ptr<AbstractClass>> vec2;
        vec1.push_back(std::make_unique<SubClass1>());
        vec2.push_back(std::make_unique<SubClass1>());
        BaseClass(vec1, vec2);
    }
    //OR SubClass2(std::vector<std::unique_ptr<AbstractClass>> vec1, std::vector<std::unique_ptr<AbstractClass>> vec2): BaseClass(vec1, vec2)
    int getId() override {
        return 2;
    }
};

"project.cpp"

#include "project.h"
int main(){
   vector<unique_ptr<AbstractClass>> objs;
   //do I instead need to pass in my vectors here so I can do SubClass2(v1, v2): BaseClass(v1, v2)?
   // std::vector<std::unique_ptr<AbstractClass>> v1;
   // v1.push_back(make_unique<SubClass1>());
   // std::vector<std::unique_ptr<AbstractClass>> v2;
   // v2.push_back(make_unique<SubClass1>());
   // std::make_unique<SubClass2>(v1, v2);
   vector.push_back(make_unique<SubClass2>());
   doSomething(objs);
}

Answer 1

In c++ is impossibile to access the private members of a class in a sub-class.

There are 3 methods to remedy this:

• declare the members as protected so that only the sub-classes can access them.

• declare "set" functions so that the members can be setted (declare them protected if you want only the sub-classes access them).

• create a costructor in base class that initialize the vector with some parameter or with a default (declare it protected if you want only the sub-classes access them) and then call it in the sub-classes.

Answer 2

As shown in the comment section, I don't really understand what you want to accomplish, but

How to initialize private members of parent class from subclass's constructor [...] without going through the initalizer list?

seems like a constructed problem. I doubt avoiding the member initializer list is the main purpose, so here's how you could do it using it.

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

class AbstractClass {
public:
    virtual int getId() = 0;
    virtual ~AbstractClass() = default;
};

// headache-saving alias
using vac_ptr = std::vector<std::unique_ptr<AbstractClass>>;

class BaseClass : public AbstractClass {
public:
    // moving, not copying
    BaseClass(vac_ptr&& v1, vac_ptr&& v2) : vec1_(std::move(v1)), vec2_(std::move(v2)) {}

    // references, not copies
    vac_ptr& getVec1() { return vec1_; }
    vac_ptr& getVec2() { return vec2_; }

private:
    vac_ptr vec1_;
    vac_ptr vec2_;
};

class SubClass1 : public AbstractClass {
public:
    int getId() override { return 1; }
};

class SubClass2 : public BaseClass {
private:
    // verbose helpers that you can fill with stuff
    vac_ptr filler1() {
        vac_ptr vec1;
        vec1.emplace_back(std::make_unique<SubClass1>());
        return vec1; // RVO
    }
    vac_ptr filler2() {
        vac_ptr vec2;
        vec2.emplace_back(std::make_unique<SubClass1>());
        return vec2; // RVO
    }

public:
    // temporaries, moved into base - via the member initializer list
    SubClass2() : BaseClass(filler1(), filler2()) {}
    int getId() override { return 2; }
};

int main() {}

The next level, moving a std::vector<std::unique_ptr<AbstractClass>> into a SubClass2 is no different if that's what you want to do next.