Running specific const/non-const method

Assume this class:

Code:

class B;

class C
{
  public:
    B* Get();
    const B* Get() const;
};

Is there a way to specifically call one of those methods, like calling the non-const method though the const-version would work too? (normally const-methods are prefered over non-const)

Is this in the ballpark?
http://www.parashift.com/c++-faq-lit...html#faq-18.12

Not really!

Code:

C c;

B* b1 = c.Get(); //The first Get is called
const B* b2 = c.Get(); //The second Get is called

But assume I (for some weird unknown totally irrational reason) want the second Get to be called in the first example (b1)? That's not possible, or? (without casting to const B* which would work here but maybe not in the general case)

Anyway, maybe my question is completely irrational and stupid.

You can't use the second get for b1 because b1 is a non-const pointer and the second Get() returns a const pointer.

I wouldn't be surprised if the first get was called in both situations. I think it usually depends on c, not b1 or b2.

The best way to force the const version to be called is to create a const reference to c and call Get() from that. In the first example it won't work because b1 is not const, but in the second example it will force the const version of Get to be called, which is usually where this is an issue.

You can't use the second get for b1 because b1 is a non-const pointer and the second Get() returns a const pointer.

I meant the other way around, use the first Get for b2 (hope it got right this time ).

One way to do what you want is to declare a function ptr to each function. Then you can use the pointers to call whichever function you want.

Code:

#include <iostream>
using namespace std;

class B
{
};

class C
{
public:
	void get()
	{
		cout<<"non-const get() called"<<endl;
	}
	void get() const
	{
		cout<<"const get() called"<<endl;
	}
};


int main()
{

	C nonConstMyC;
	nonConstMyC.get(); //calls non-const get()

	const C constMyC;
	constMyC.get();  //calls const get()

	cout<<endl;

	cout<<"Non-const C object used to call both functions:"<<endl;
	//Declare a pointer to the const get():
	void (C::*ptrConstGet)() const = C::get; 
	//Use the non-const C to call the const get():
	(nonConstMyC.*ptrConstGet)();
	
	//Declare a pointer to the non-const get():
	void (C::*ptrNonConstGet)() = C::get;
	//Use the non-const C to call the non-const get():
	(nonConstMyC.*ptrNonConstGet)();

	return 0;
}

Actually, you only need to declare one function pointer: a pointer to the const get(). Then, you can call both functions like this:

Code:

nonConstMyC.get();
(nonConstMyC.*ptrConstGet)()