Re: Smart Pointer problem
* Saurabh Gupta:
We have our smart pointer implementation. But the operator -> is
creating problem in case of a const pointer. It's always returning a
non-const pointer, therefore, we are able to call a non const function
on a const pointer. How can we overcome this problem?
Smart pointer code.
/**
* Returns the raw pointer for use in calling member functions.
*/
T *operator->() const
{
return m_p;
}
Sample Code:
class Test {
public:
void ChangeData(int a, int b)
{
X = a;
Y = b;
}
private:
int x;
int y;
};
typedef CC::CSmartPointer<Test> TestPtr;
Void TestData(const TestPtr& test)
{
// here. We should get the compilation error. But it?s
// working fine due to behavior of the Smart Pointer operator -> .
test->ChangeData(x, y);
}
If I understand correctly you want constness of a smart pointer to ensure
constness of the contained pointer's referent.
Consider
TestPtr const p1( ... );
TestPtr p2( p1 ); // Non-const access granted.
I'm pretty sure that that's not the wished-for functionality! :-)
In short, the concept is only meaningful if the smart pointer is not copyable.
Instead you can declare the smart pointer's referent to be const, e.g.
SmartPtr<T const> p1( ... );
SmartPtr<T> p2( p1 ); // Will not compile.
But when you have on hand a typedef'ed smart pointer type name such as TestPtr
above, how do you specify that you want a version where the referent is const?
Well, one solution is to always define two pairs of type names, e.g.
typedef SmartPtr<Test> TestPtr;
typedef SmartPtr<Test const> TestPtrConst;
and then you could define a macro, e.g. SMART_CONST_PTR, that added "Const" to
the end of the name, and write SMART_CONST_PTR(SmartPtr).
But you may not control the code where the typedef resides.
And besides, relying on conventions (such as naming conventions) is generally
ungood, and macros are generally ungood.
Ideally, you should be able to write something like
void testData( SmartConstPtr_<TestPtr>::Type test )
{
test->changeData( x, y ); // Compile error.
}
And you can do that by adding some machinery to add const to a smart pointer's
referent type, e.g.
template< class SmartPtr >
struct SmartConstPtr_;
template< template <class> class SmartPtr_, typename Referent >
struct SmartConstPtr_< SmartPtr_< Referent > >
{
typedef SmartPtr_< Referent const > Type;
};
Cheers, & hth.,
- Alf
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]