Call constructor with different argument types from another constructor in C++17

I have a class called Date:

class Date {
public:
    explicit Date(const int day = 1, const int month = 1, const int year = 0) {
        this->Construct(day, month, year);
    }

    explicit Date(const string &date_as_string) {
        int day, month, year;
        // parsing the string date_as_string
        this->Construct(day, month, year);
    }

private:
    void Construct(const int day, const int month, const int year) {
        // constructing the Date object
    }
};

Is there a way to call Date(int, int, int) directly from Date(string&), thus avoiding writing a separate function?

UPD:

Some clarification. My class should look like:

class Date {
public:
    explicit Date(const int day = 1, const int month = 1, const int year = 0) {
        // constructing the Date object
    }

    explicit Date(const string &date_as_string) {
        int day, month, year;
        // parsing the string date_as_string
        // call Date(day, month, year) to construct the Date object
    }

  // any other functions

private:
    // private fields
};

And the following code should compile:

Date date("some_string_containing_date");
Date date(1, 1, 0);

Yes, you can define one constructor in terms of another. No, I don't think you can do it without some additional function.

A constructor which invokes another constructor of the same class is called a "delegating constructor", and uses the same sort of syntax as a member initializer list, but using the class's own name instead of its base classes and members:

ClassName::ClassName(SomeParam1 p1, SomeParam2 p2)
    : ClassName(arg_expr1, arg_expr2, arg_expr3)
{ /* any other logic after the target constructor finishes */ }

But this case is a bit tricky because of the need for the intermediate object date_as_struct. Or with the updated question, just the need to do some parsing before entering another constructor. I'd solve this one by making an additional private constructor which takes the Date_as_struct:

class Date {
public:
    explicit Date(int day = 1, int month = 1, int year = 0); 
    explicit Date(const string &date_as_string);
    /* ... */
private:
    struct Date_as_struct {
        int day;
        int month;
        int year;
    };

    explicit Date(const Date_as_struct&);
    
    static Date_as_struct ParseStringContainingDate(const std::string&);
};

Date_as_struct and ParseStringContainingDate are declared here as private, since it sounds like nothing else will really use them.

Then for the string constructor, you just have

Date::Date(const std::string& date_as_string)
    : Date(ParseStringContainingDate(date_as_string))
{}

The Date(const Date_as_struct&) constructor can very easily delegate to Date(int, int, int) or vice versa, whichever is more natural for the actual member initialization.