SmartPtr type conversion error

T

tsar.omen

Hello everyone,
during my coding practice I have encounted the following problem:

Vital code pieces:


---
template <class T> class SmartPtr

{

private:

Reference<T>* ref; // object with pointer to T and ref counter

public:

SmartPtr() : ref(0) {}

SmartPtr(T* t) : ref(new Reference<T>(t)) {}

SmartPtr(SmartPtr& h) : ref(h.acquire()) {}

SmartPtr& operator = (T* t) {/**/}

SmartPtr& operator = (SmartPtr& h) {/**/}

~SmartPtr() { freeReference(); }

private:

void freeReference() {/**/}

Reference<T>* acquire () {/**/}

};
---


Now to introduce the problem:

(1) works:
SmartPtr<Foo> pFoo(new Foo()); // direct initialization
(SmartPtr::SmartPtr(T*))

(2) works:
SmartPtr<Foo> pFoo1(new Foo());
SmartPtr<Foo> pFoo2(pFoo1); // direct initialization
(SmartPtr::SmartPtr(SmartPtr&))

(3) works:
SmartPtr<Foo> pFoo; // SmartPtr::SmartPtr()
pFoo = new Foo(); // operator=(T *)
pFoo = pFoo7; // operator=(SmartPtr&)

!(4) does _NOT_ work:

SmartPtr<Foo> pFoo = new Foo();

It produces the following error on gcc 3.3.6:

---
main.cc:24: error: no matching function for call to
`SmartPtr<Point>::SmartPtr( SmartPtr<Point>)'
smartptr.h:162: error: candidates are:
SmartPtr<T>::SmartPtr(SmartPtr_ref<T>)
[with T = Point]
smartptr.h:73: error:
SmartPtr<T>::SmartPtr(SmartPtr<T>&) [with T = Point]
smartptr.h:70: error: SmartPtr<T>::SmartPtr(T*) [with T
=
Point]
main.cc:24: error: initializing temporary from result of `
SmartPtr<T>::SmartPtr(T*) [with T = Point]'
---

AFAIK in case 'SmartPtr<Foo> pFoo = new Foo();' a copy initialization
is used. That's firstly applying conversion operator to the right side
and then calling a copy constructor. Because right side in in fast T* t
so SmartPtr::SmartPtr(T*) was chosen, resulting in creation of
temporary object and trying to copy initialize pFoo with tmp object
which fails [SmartPtr<Point>::SmartPtr(SmartPtr<Point>) as reported by
g++].

My question is if it's possible to somehow fix it to allow construction
like 'SmartPtr<Foo> pFoo = new Foo();' legal.

Many thanks in advance.
 
M

mlimber

Hello everyone,
during my coding practice I have encounted the following problem:

Vital code pieces:


---
template <class T> class SmartPtr

{

private:

Reference<T>* ref; // object with pointer to T and ref counter

public:

SmartPtr() : ref(0) {}

SmartPtr(T* t) : ref(new Reference<T>(t)) {}

SmartPtr(SmartPtr& h) : ref(h.acquire()) {}

SmartPtr& operator = (T* t) {/**/}

SmartPtr& operator = (SmartPtr& h) {/**/}

~SmartPtr() { freeReference(); }

private:

void freeReference() {/**/}

Reference<T>* acquire () {/**/}

};
---


Now to introduce the problem:

(1) works:
SmartPtr<Foo> pFoo(new Foo()); // direct initialization
(SmartPtr::SmartPtr(T*))

(2) works:
SmartPtr<Foo> pFoo1(new Foo());
SmartPtr<Foo> pFoo2(pFoo1); // direct initialization
(SmartPtr::SmartPtr(SmartPtr&))

(3) works:
SmartPtr<Foo> pFoo; // SmartPtr::SmartPtr()
pFoo = new Foo(); // operator=(T *)
pFoo = pFoo7; // operator=(SmartPtr&)

!(4) does _NOT_ work:

SmartPtr<Foo> pFoo = new Foo();

It produces the following error on gcc 3.3.6:

---
main.cc:24: error: no matching function for call to
`SmartPtr<Point>::SmartPtr( SmartPtr<Point>)'
smartptr.h:162: error: candidates are:
SmartPtr<T>::SmartPtr(SmartPtr_ref<T>)
[with T = Point]
smartptr.h:73: error:
SmartPtr<T>::SmartPtr(SmartPtr<T>&) [with T = Point]
smartptr.h:70: error: SmartPtr<T>::SmartPtr(T*) [with T
=
Point]
main.cc:24: error: initializing temporary from result of `
SmartPtr<T>::SmartPtr(T*) [with T = Point]'
---

AFAIK in case 'SmartPtr<Foo> pFoo = new Foo();' a copy initialization
is used. That's firstly applying conversion operator to the right side
and then calling a copy constructor. Because right side in in fast T* t
so SmartPtr::SmartPtr(T*) was chosen, resulting in creation of
temporary object and trying to copy initialize pFoo with tmp object
which fails [SmartPtr<Point>::SmartPtr(SmartPtr<Point>) as reported by
g++].

My question is if it's possible to somehow fix it to allow construction
like 'SmartPtr<Foo> pFoo = new Foo();' legal.

Many thanks in advance.

This is an issue of constness and an optimization. Specifically, some
initialization optimization is taking place in your fourth example but
because your parameter to the copy constructor is not const, you cannot
bind an rvalue to it. In short, you need to add const as such:

SmartPtr( const SmartPtr& h) : ref(h.acquire()) {}

Reference<T>* acquire() const {/**/}

Cheers! --M
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,904
Latest member
HealthyVisionsCBDPrice

Latest Threads

Top