SmartPtr type conversion error

Collapse
This topic is closed.
X
X
Collapse
 
  • Page of 1
  • Time
  • Show
Clear All
new posts
Previous template Next
  • tsar.omen@gmail.com
    #1

    SmartPtr type conversion error

    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(SmartP tr& 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::Smar tPtr(T*))

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

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

    !(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>::Sm artPtr(SmartPtr _ref<T>)
    [with T = Point]
    smartptr.h:73: error:
    SmartPtr<T>::Sm artPtr(SmartPtr <T>&) [with T = Point]
    smartptr.h:70: error: SmartPtr<T>::Sm artPtr(T*) [with T
    =
    Point]
    main.cc:24: error: initializing temporary from result of `
    SmartPtr<T>::Sm artPtr(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::Smart Ptr(T*) was chosen, resulting in creation of
    temporary object and trying to copy initialize pFoo with tmp object
    which fails [SmartPtr<Point> ::SmartPtr(Smar tPtr<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.

    --
    zakkath

    Tags: None
    • mlimber
      #2
      Re: SmartPtr type conversion error

      tsar.omen@gmail .com wrote:[color=blue]
      > 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(SmartP tr& 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::Smar tPtr(T*))
      >
      > (2) works:
      > SmartPtr<Foo> pFoo1(new Foo());
      > SmartPtr<Foo> pFoo2(pFoo1); // direct initialization
      > (SmartPtr::Smar tPtr(SmartPtr&) )
      >
      > (3) works:
      > SmartPtr<Foo> pFoo; // SmartPtr::Smart Ptr()
      > pFoo = new Foo(); // operator=(T *)
      > pFoo = pFoo7; // operator=(Smart Ptr&)
      >
      > !(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>::Sm artPtr(SmartPtr _ref<T>)
      > [with T = Point]
      > smartptr.h:73: error:
      > SmartPtr<T>::Sm artPtr(SmartPtr <T>&) [with T = Point]
      > smartptr.h:70: error: SmartPtr<T>::Sm artPtr(T*) [with T
      > =
      > Point]
      > main.cc:24: error: initializing temporary from result of `
      > SmartPtr<T>::Sm artPtr(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::Smart Ptr(T*) was chosen, resulting in creation of
      > temporary object and trying to copy initialize pFoo with tmp object
      > which fails [SmartPtr<Point> ::SmartPtr(Smar tPtr<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.
      >
      > --
      > zakkath[/color]

      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

        Comment

        Previous template Next
        Working...