C++ 在构造函数中初始化 object（多态）

Question

I am currently trying to achieve something in C++ I do in Java all the time: Let's say that I have a function bool init() as a member of my class A that gets called in the constructor of A and if it returns false , the constructor will throw an exception.

Now I create a new class B that derives from A but it needs to perform a different initialization so it will return true in different cases than the original A::init() .

In Java I'd simply go ahead and overwrite the method in B and when the constructor of A is involed in the process of constructing B , it will call B::init() from A's constructor and the thing works like a champ.

In C++ however I just learned that I can't call virtual functions in a constructor (that is I can but it doesn't behave the same way). My question now is, how I can handle such initializations/checks that are invoked from the constructor but that might need to be changed in a derivative of a class.
One way would of course be to not call that in the constructor but leave it to the programmer to explicitly call the init() function after creating the object but I don't like that as this could be forgotten leading to strange object state.

---

Small example:
Consider that A and B read a hardcoded file's content. A reads fileA.txt and B reads fileB.txt . I want the construction of the object to only succeed if the respective file is present. Thus the check has to happen in the constructor of the object. If writing the check into the constructor directly will cause B to always fail (assuming that both files can't exist at the same time) so I always went for defining a function that performs the check and that can be overwritten. What's the C++ way of do this?

Answer 1

Whereas having derived class call its own init function seems more appropriate, as alternative, you can create factory function which call your virtual init method:

class A
{
public:
    virtual ~A() = default;
    virtual bool init() = 0;

public:
    template <typename T, typename ... Ts>
    static T Create(Ts&&...args)
    {
        static_assert(std::is_base_of<A, T>::value);
        T derived(std::forward<Ts>(args)...);
        if (!derived.init()) {
            throw std::runtime_error("...");
        }
        return derived;
    }
protected:
    A() = default;
};

class B : public A
{
    friend class A; // For factory
protected:
    B(/*..*/);
public:
    bool init() override;
};

Answer 2

For your example you should write an abstract base class from which A & B inherit with a pure virtual static const function which directs which file is read. Abstract classes in C++ are more powerful than interfaces in Java and can consequently be more useful to resolve these kinds of issues than would a java interface.

To actually solve this problem is a more in depth issue which has thus far had me staring at the C++ spec for an hour now trying to figure out. I'll give an update when I figure out exactly what the spec is saying and how if possible to do this. This one has really got me.