const and non const getter : C2248: cannot access private member declared in class

Question

I have a class which implements a getter to an std::vector . Derived classes are allowed to change the content of the vector, while any other class may read it (or make a copy in my case), but not change it.

SSCCE with Visual Studio 2010 (but should compile with any other as well).

So in the base class I implemented the getter like this:

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstring>
#include <string>
#include <vector>

    class X
    {
    public:
        inline std::vector<std::string> const &getChilds(void) const
        {
            return mChilds;
        }

        void mutateInternal(void)
        {
            mState != mState;
        }

    protected:
        inline std::vector<std::string> &getChilds(void)
        {
            return mChilds;
        }

    private:
        std::vector<std::string> mChilds;
        bool mState;
    };

// Now in the derived class

    class Y : public X
    {
    public:
        Y(void)
        {
            std::vector<std::string> &childs = getChilds();
            childs.push_back("Test");
        }

    };

// In the non derived class:

    class Z
    {
    public:
        void myfunction(void)
        {
            Y y;

            std::vector<std::string> s = y.getChilds();
            if(s.size() == 0)
                y.mutateInternal();

        }

    };


int main(int argc, char *argv[])
{
    return 0;
}

But I get the error

1>junk.cpp(49): error C2248: "X::getChilds": cannot access private member declared in class.
1>          junk.cpp(18): Siehe Deklaration von 'X::getChilds'
1>          junk.cpp(10): Siehe Deklaration von 'X'

and I don't really see what is wrong with that and why the compiler doesn't take the public version which is const and instead insists on the non-const.

Even if I change the variable to const &s (which wouldn't help in this case) I still get the same error.

Update:

Edited the SSCCE for calling const and non const functions.

Answer 1

In this case it should be

const Y y;

in Z::my_function for call const version of function. Live Or just cast to const Y , like

std::vector<std::string> s = const_cast<const Y&>(y).getChilds();

Your case don't work, since access check will be applied only after overload resolution, in call y.getChilds() non-const overload will be picked, since it has the best match.