Cannot access protected member in template

Question

5.00/5 (3 votes)

See more:

, +

VS 2012 gives an 'error C2248: ... cannot access protected member declared in class...' in the following minimal code stripped from a complete project. VS 2008 has no problems with it, and executes as expected.

The line right before the issue calls the protected member in question, and no errors are given, as it should be. The template's construction is when the problem appears.

C++

class DwlWinObject {
   };

class DwlDelegate {
   public:
      int junk;
      template <class T, void (T::*Method)(DwlWinObject*)>
      static DwlDelegate create(T* object_ptr, DwlWinObject * arg) {
         DwlDelegate d;
         d.junk = 12;
         return d;
         }
   };
   
class ModalBaseWindow : public DwlWinObject {
   protected:
      int a;
      void accept(DwlWinObject*) {
         a=0;
         }
   };

class MyModalWindow : public ModalBaseWindow {
   public:
      MyModalWindow() {
         accept(this);  //2008: No problem accessing 'accept'
         //But VS2012 gives C2248 compile error on the next line.
         //C2248 is 'cannot access protected member'
         //VS2008 has no problems with it, and executes as expected.
         DwlDelegate d = DwlDelegate::create<ModalBaseWindow,
                     &ModalBaseWindow::accept>(this, this);
         int test = d.junk;
         d.junk = 15;
         }
   };

void main() {
   MyModalWindow win;
   }

Is this a bug in Visual Studio 2012, or did something in the standards change? As I don't really want to make the accept routine public, is my best option to create an accept function in the MyModalWindow class which calls the ModalBaseWindow::accept? In the full application that's a lot of additional code for all of the subclasses involved for something which once worked.

Thanks,
David

Posted 12-Jul-13 22:50pm

David O'Neil

Add a Solution

2 solutions

Solution 1

The rules did change but I don't think that's the problem. I think it's just that Microsoft started applying the existing ones.
It's a tricky case but I think the problem can be summarized as trying to use a protected member function pointer as a template parameter to a function that does not have access to that member.
The two ways to solve this are to give the create function the access it needs or to unprotect the access function which is definitely the last resort.

The easiest way I can see to give the create function access without wider impact on the code is to make the delegate a friend of ModalBaseWindow

C#

class ModalBaseWindow : public DwlWinObject {

   friend class DwlDelegate;

   protected:
      int a;
      void accept(DwlWinObject*) {
         a=0;
         }
   };

The problem with this is that template member friend rules are about the outer limits of the C++ spec and are even more likely to be broken in the MSVC compiler than what you already have. Anyway, give it a try and let me know.

Posted 13-Jul-13 0:35am

Matthew Faithfull

Comments

David O'Neil 13-Jul-13 8:06am

Seldom used this before, so didn't see how to comment. But deleted my other reply now that it is abundantly obvious!

Unfortunately, friending it doesn't work. I'm seriously thinking about the public route to save time. Thanks for the input!

Matthew Faithfull 13-Jul-13 8:14am

No problem. Your choice as to how much time to invest in it.
I tend to find there is usually a way to persuade these things to work but not always. If you have the opportunity then trying under a completely different compiler like the latest GCC or CLang might be a useful exercise.
If it works there without warnings then there's a good chance you're right and MS is wrong. If not then the combined set of errors/ warnings across several compiler might give enough clues to crack it.

There is another option which is to pass the member function pointer as a runtime parameter rather than having it as part of the signature of create. This obviously open up the possibility of having to change more code but it might not be too bad.

David O'Neil 13-Jul-13 9:17am

You mean something like this?

class DwlWinObject {
};

class ModalBaseWindow;

template <class t>
class DwlDelegate {
typedef void (T::*FuncPtr)(DwlWinObject*);
protected:
FuncPtr ptrC;
public:
int junk;
static DwlDelegate create(T* object_ptr, DwlWinObject * arg, FuncPtr ptr) {
DwlDelegate d;
d.junk = 12;
return d;
}

};

class ModalBaseWindow : public DwlWinObject {
protected:
int a;
void accept(DwlWinObject*) {
a=0;
}
};

class MyModalWindow : public ModalBaseWindow {
public:
MyModalWindow() {
accept(this); //2008: No problem accessing 'accept'
//But VS2012 gives C2248 compile error on the next line.
//C2248 is 'cannot access protected member'
//VS2008 has no problems with it, and executes as expected.
DwlDelegate<mymodalwindow> d = DwlDelegate<mymodalwindow>::create(this, this, &ModalBaseWindow::accept);
int test = d.junk;
d.junk = 15;
}
};

void main() {
MyModalWindow win;
}

If so, that's also a no-go. I was surprised it took the 'd = line. [edit - I mean that it didn't barf up a template error instead of the 'can't access' error!] Templates make my head hurt!

Thanks,
David

Matthew Faithfull 13-Jul-13 9:34am

When you say a no-go, do you get the same error? What about in combination with the friend declaration?
I find it hard to believe it won't let you do that. The only further step I can think of is making the function pointer typedef in the delegate public and actually cast the address of ModalBaseWindow::accept before you pass it but that is getting truly horrible and I don't believe it should be necessary.
...
Spotted one thing, your d = does need to be DwlDelegate <ModalBaseWindow> or it definitely isn't going to work as MyModalWindow doesn't have an accept function.

Templates make everyone's heads hurt, even the compiler writers. :-)

David O'Neil 13-Jul-13 10:08am

Thank you for the feedback. Yes, I get the same error regardless of the approach. Even the following gives the exact same thing, whether or not I cast in the d = line. I don't have another compiler installed, and even though it would be fun to play and see, I'm going to skip on that for now.

class DwlWinObject {
};

template <class T>
class DwlDelegate {
public:
typedef void (T::*FuncPtr)(DwlWinObject*);
protected:
FuncPtr ptrC;
public:
int junk;
static DwlDelegate create(T* object_ptr, DwlWinObject * arg, FuncPtr ptr) {
DwlDelegate d;
d.junk = 12;
return d;
}
};

class ModalBaseWindow : public DwlWinObject {
friend class DwlDelegate<ModalBaseWindow>;
protected:
int a;
void accept(DwlWinObject*) {
a=0;
}
};

class MyModalWindow : public ModalBaseWindow {
public:
MyModalWindow() {
accept(this); //2008: No problem accessing 'accept'
//But VS2012 gives C2248 compile error on the next line.
//C2248 is 'cannot access protected member'
//VS2008 has no problems with it, and executes as expected.
DwlDelegate<modalbasewindow> d = DwlDelegate<modalbasewindow>::create(this, this,
(DwlDelegate<modalbasewindow>::FuncPtr)(&ModalBaseWindow::accept));
int test = d.junk;
d.junk = 15;
}
};

void main() {
MyModalWindow win;
}

(And don't ask me why a copy/paste results in ModalBaseWindow loosing its capitalization when inside < >)

Matthew Faithfull 13-Jul-13 11:22am

In that case it isn't allowing MyModalWindow to take the address of a function from its own base class. That is odd and really is, I think, a change in the rules. Still it can no doubt be worked around. I would try making accept a virtual function. Don't need to override it just make the ModalBaseWindow member virtual.
I think that will do it, then it's a matter of how many of the other changes you can roll back and still have it work.

David O'Neil 13-Jul-13 11:33am

Not even that works. Same error.

Matthew Faithfull 13-Jul-13 11:46am

I'm all out at this point I'm afraid. I would probably go for the public: accept function but it seems a shame.

David O'Neil 13-Jul-13 12:06pm

I will make it so, and yes it is. Thank you very much for your time and knowledge!

H.Brydon 13-Jul-13 10:56am

Great question, great effort on the answer. +5 for both.

Does making accept() static change anything? You are passing 'this' in anyhow...

Matthew Faithfull 13-Jul-13 11:23am

Thanks H. So far it's good but not Stilton on this one I'm afraid.

David O'Neil 13-Jul-13 11:46am

By changing the other places appropriately (the typedef and such), it will compile. But you lose the ability to do anything interesting in the accept function unless you resort to static member variables as well.

A full-blown solution is to go to the std::function approach I outline in this article, but I'm not ready to take that plunge at this stage. [EDIT] - Now that I think about it, even that probably won't work, because of the same issue - I'm getting tired.[/EDIT] Another, to overcome the static problem, is the one I hinted at in the question:

class DwlWinObject {
};

template <class T>
class DwlDelegate {
public:
typedef void (T::*FuncPtr)(DwlWinObject*);
protected:
FuncPtr ptrC;
public:
int junk;
static DwlDelegate create(T* object_ptr, DwlWinObject * arg, FuncPtr ptr) {
DwlDelegate d;
d.junk = 12;
return d;
}
};

class ModalBaseWindow : public DwlWinObject {
protected:
int a;
virtual void accept(DwlWinObject*) {
int a=0;
}
};

class MyModalWindow : public ModalBaseWindow {
public:
MyModalWindow() {
DwlDelegate<MyModalWindow> d = DwlDelegate<MyModalWindow>::create(this, this,
&MyModalWindow::accept);
int test = d.junk;
d.junk = 15;
}
inline void accept(DwlWinObject * ptr) {
return ModalBaseWindow::accept(ptr);
}
};

void main() {
MyModalWindow win;
}

I suspect the compiler shouldn't be allowing me to specify inline on the accept override, and will really ignore it, and a similar function has to be added to every other derived unit. But at least now I know my options.

pasztorpisti 13-Jul-13 13:10pm

Doesn't this code work in VS2012 by simply deleting the inline accept method from the MyModalWindow class?

David O'Neil 13-Jul-13 13:55pm

Yes, since I had the MyModalWindow throughout the d = call. But I was too tired to realize that, and the inline idea was fixed in my mind... Again, thanks!

pasztorpisti 13-Jul-13 13:59pm

You are welcome! Happy end.

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

pasztorpisti · Accepted Answer · 2013-07-13T07:06:00

Unfortunately I have no VS2012 at hand but I have a g++ that has always been my friend when I wanted to check whether a piece of code follows the standard or not. Using my VS2010 and g++4.5 (cygwin) I have put together the following example program that may serve you with some useful info:

C++

class DwlWinObject {};

class Delegate
{
public:
    virtual void Call(DwlWinObject* param) = 0;

    template <typename T>
    static Delegate* Create(T* const obj, void (T::*method)(DwlWinObject*));
};

template <typename T>
class TDelegate : public Delegate
{
public:
    virtual void Call(DwlWinObject* param)
    {
        (m_Obj->*m_Method)(param);
    }
    TDelegate(T* obj, void (T::*method)(DwlWinObject*))
    {
        m_Obj = obj;
        m_Method = method;
    }
private:
    T* m_Obj;
    void (T::*m_Method)(DwlWinObject*);
};

template <typename T>
Delegate* Delegate::Create(T* const obj, void (T::*method)(DwlWinObject*))
{
    return new TDelegate<T>(obj, method);
}

class ModalBaseWindow : public DwlWinObject
{
protected:
    void accept(DwlWinObject* param)
    {
        printf("%s(%p)\n", __FUNCTION__, param);
    }
};

class MyModalWindow : public ModalBaseWindow
{
public:
    MyModalWindow()
    {
        //accept(this);  //2008: No problem accessing 'accept'

        // compiles
        void (MyModalWindow::*Method)(DwlWinObject*) = &MyModalWindow::accept;

        // x.cpp: In constructor ‘MyModalWindow::MyModalWindow()’:
        // x.cpp:39:7: error: ‘void ModalBaseWindow::accept(DwlWinObject*)’ is protected
        // x.cpp:54:70: error: within this context
        //void (ModalBaseWindow::*Method)(DwlWinObject*) = &ModalBaseWindow::accept;

        // compiles
        Delegate* d = new TDelegate<MyModalWindow>(this, &MyModalWindow::accept);

        // x.cpp: In constructor ‘MyModalWindow::MyModalWindow()’:
        // x.cpp:39:7: error: ‘void ModalBaseWindow::accept(DwlWinObject*)’ is protected
        // x.cpp:59:72: error: within this context
        //Delegate* d = new TDelegate<ModalBaseWindow>(this, &ModalBaseWindow::accept);

        // compiles
        //Delegate* d = Delegate::Create<MyModalWindow>(this, &MyModalWindow::accept);

        // compiles
        //Delegate* d = Delegate::Create<ModalBaseWindow>(this, &MyModalWindow::accept);

        // x.cpp: In constructor ‘MyModalWindow::MyModalWindow()’:
        // x.cpp:46:7: error: ‘void ModalBaseWindow::accept(DwlWinObject*)’ is protected
        // x.cpp:81:75: error: within this context
        //Delegate* d = Delegate::Create<ModalBaseWindow>(this, &ModalBaseWindow::accept);

        // firing an event using the delegate
        d->Call(this);
    }
};

int main() {
    MyModalWindow win;
    return 0;
}

To me the conclusion is that instead of &ModalBaseWindow::accept you should try using &MyModalWindow::accept when you specify the method pointer.