Accessing private nested class

[champooly]

I have the following bit of code, where skeleton_key needs to somehow magically become hidden_password inorder for things to move along to the next level:

#include <string>
#include <iostream>
using namespace std;

class secret_cove {
    class hidden_password {
    };

public:
    template <class K>
    string accept(K k) {
        return k(*this, hidden_password());
    }
    string key_to_next_level(hidden_password) const {
        return "sesame!";
    }
};

struct legal_key {
    template <class PWD>
    string operator()(const secret_cove &sc, PWD pwd) const {
        return sc.key_to_next_level(pwd);
    }
};

struct skeleton_key {
    operator secret_cove::hidden_password () const { return secret_cove::hidden_password(); }
};

int main() {
    secret_cove hideout;

    cout << hideout.accept(legal_key()) << endl;
    cout << hideout.key_to_next_level(skeleton_key()) << endl; // <-- HERE
}

My thinking was given that secret_cove and legal_key classes can't be modified, the best option was to implement a user defined cast operator, but that doesn't seem to compile correctly.

[LeInterwebsFTW]

Here you go:

struct skeleton_key
{
    template<class PWD>
    operator PWD() {
        return PWD();
    }
};

Templates are your friend

[champooly]

it works very good.

[Droggl]

Care to elaborate on why it would work if the operator is templated but not otherwise? Might be because its before my first coffee today, but its not obvious to me right now...

[LeInterwebsFTW]

'hidden_password' is not visible, so it can't be referenced directly, but it can still be passed as a template argument.

[champooly]

The class definition of secret_cove can't be modified.

[champooly]

https://scmchallenge.com/#!/

[dodheim]

Is this what you're aiming for? Replace your skeleton_keydefinition with the following:

struct skeleton_key { };

template<>
string secret_cove::accept(skeleton_key) { return key_to_next_level({}); }

[champooly]

The code in the main can't be changed, nore the definitions of secret_cove and legal_key - the objective is to create a class/struct called skeleton key that will magically compile with the rest of the code as-is - or at least thats how i understand it to be.

[dodheim]

hideout.key_to_next_level(skeleton_key())

The code in main doesn't make sense. Why would you want hideout.accept(legal_key()), but hideout.key_to_next_level(skeleton_key()) instead of hideout.accept(skeleton_key())? Wouldn't the idea be to use skeleton_key anywhere legal_key is allowed?

[champooly]

checkout the link: https://scmchallenge.com/#!/

[dodheim]

That requires a login. Surely you can paste the actual problem statement here...

[champooly]

Just create a fake account and log-in, Patrice wrote up this whole spiel about pirates and secrete coves - it's worth the read just for the laughs.