Converting C++ to Qt4

[ComaWhite]

Hello. I have this class in pure C++.

#ifndef VALUEVECTOR_HPP_
#define VALUEVECTOR_HPP_
 
#include <iostream>
#include <vector>
#include <algorithm>
using std::cout;
using std::endl;
using std::vector;
using std::find;
#include "Object.hpp"
#include "ComaPtr.hpp"
#include "Value.hpp"
 
class ValueVector : public Object {
    typedef ComaPtr<Value> type;
public:
 
    ValueVector() {
    }
 
    ValueVector(Value* value) {
        clearChildren();
        addChildren(value);
    }
 
    ValueVector(unsigned length) {
        clearChildren();
        size(length);
    }
 
    ValueVector(const ValueVector& rhs) {
        *this = rhs;
    }
 
    type& operator[](unsigned index) {
        return m_children[index];
    }
 
    bool operator==(ValueVector& vv) {
        if(size() != vv.size()) {
            return false;
        }
 
        for(unsigned i = 0; i < size(); ++i) {
            for(unsigned j = 0; j < vv.size(); ++j) {
                if(m_children[i] != vv[i]){
                    return false;
                }
            }
        }
        return true;
    }
 
    bool operator!=(ValueVector& vv) {
        if(size() != vv.size()) {
            return true;
        }
 
        for(unsigned i = 0; i < size(); ++i) {
            for(unsigned j = 0; j < vv.size(); ++j) {
                if(m_children[i] != vv[i]){
                    return true;
                }
            }
        }
        return false;
    }
 
    void addChildren(type children) {
        assert(find(m_children.begin(), m_children.end(), children) == m_children.end());
        m_children.push_back(children);
    }
 
    unsigned capacity() const {
        return m_children.capacity();
    }
 
    void capacity(unsigned length) {
        m_children.reserve(length);
    }
 
    void clearChildren() {
        m_children.clear();
    }
 
    void setChildren(unsigned index, type children) {
        assert(index < size());
        m_children[index] = children;
    }
 
    unsigned size() const {
        return m_children.size();
    }
 
    void size(unsigned length) {
        m_children.resize(length);
    }
private:
    vector<type> m_children;
};
 
typedef ComaPtr<ValueVector> ValueVectorPtr;
 
#endif /*VALUEVECTOR_HPP_*/

#ifndef VALUEVECTOR_HPP_
#define VALUEVECTOR_HPP_

#include <iostream>
#include <vector>
#include <algorithm>
using std::cout;
using std::endl;
using std::vector;
using std::find;
#include "Object.hpp"
#include "ComaPtr.hpp"
#include "Value.hpp"

class ValueVector : public Object {
    typedef ComaPtr<Value> type;
public:

    ValueVector() {
    }

    ValueVector(Value* value) {
        clearChildren();
        addChildren(value);
    }

    ValueVector(unsigned length) {
        clearChildren();
        size(length);
    }

    ValueVector(const ValueVector& rhs) {
        *this = rhs;
    }

    type& operator[](unsigned index) {
        return m_children[index];
    }

    bool operator==(ValueVector& vv) {
        if(size() != vv.size()) {
            return false;
        }

        for(unsigned i = 0; i < size(); ++i) {
            for(unsigned j = 0; j < vv.size(); ++j) {
                if(m_children[i] != vv[i]){
                    return false;
                }
            }
        }
        return true;
    }

    bool operator!=(ValueVector& vv) {
        if(size() != vv.size()) {
            return true;
        }

        for(unsigned i = 0; i < size(); ++i) {
            for(unsigned j = 0; j < vv.size(); ++j) {
                if(m_children[i] != vv[i]){
                    return true;
                }
            }
        }
        return false;
    }

    void addChildren(type children) {
        assert(find(m_children.begin(), m_children.end(), children) == m_children.end());
        m_children.push_back(children);
    }

    unsigned capacity() const {
        return m_children.capacity();
    }

    void capacity(unsigned length) {
        m_children.reserve(length);
    }

    void clearChildren() {
        m_children.clear();
    }

    void setChildren(unsigned index, type children) {
        assert(index < size());
        m_children[index] = children;
    }

    unsigned size() const {
        return m_children.size();
    }

    void size(unsigned length) {
        m_children.resize(length);
    }
private:
    vector<type> m_children;
};

typedef ComaPtr<ValueVector> ValueVectorPtr;

#endif /*VALUEVECTOR_HPP_*/

To copy to clipboard, switch view to plain text mode 

And I was googling around for like a Smart Pointer in Qt4.4 but I couldn't seem to come up with any answers except for QGuardedPtr<> but only seems to appear in Qt3 which I don't use.

ComaPtr<> is like boost::shared_ptr except my pointer class addRef and release which is all done in ComaPtr<> which only works on classes that inherit from my custom reference counting class Object. And was wondering. how do I set up QVector to hold an array of pointers of Value (example class). And automatically reference count it?

[caduel]

Did you take a look at QSharedDataPointer?

Also, nothing stops you from using boost::shared_ptr together with Qt...

[ComaWhite]

Thank you. So one question. I think from reading the doc on it. It will automatically allow a end-user to do like Value* v = new Value(22); and not have to worry about deleting it?

[caduel]

no, something like that is just about impossible in C++.

The way I read it, it works like boost::shared_ptr.

QSharedDataPointer<Value> v = new Value(22);

You have to assign the 'naked' pointer to a QSharedDataPointer. Once the (last copy of this) QSharedDataPointer goes out of scope the reference count gets zero and the object deleted.
(Note that this is a huge difference to boost::shared_ptr: a QSharedDataPointer "detaches" when you call a non-const op on it (effectifely creating a separate copy).
This is what you want for a value-like class like QString (see below). It might not be at all what you want.)
If you do not want to implement a shared value class, stick to boost::shared_ptr, imo.


The other thing is, that this class was designed for implementing 'value-like' shared objects. Like a QString.
You will hardly ever write

QString *s = new QString;

QString *s = new QString;

To copy to clipboard, switch view to plain text mode 

QString hides this and maybe uses a QSharedDataPointer internally.
The docs illustrated how to do this.
(This is basically a more adavanced form of the pimpl idiom with better support for efficient (and correct) copying of objects.)

HTH

[wysota]

QSharedDataPointer operates on QSharedData, so this is probably not going to work.

Something like:

SomeTypeVeryWisePointer ptr = new SomeType;

SomeTypeVeryWisePointer ptr = new SomeType;

To copy to clipboard, switch view to plain text mode 

doesn't make much sense if you want the data to be deleted when ptr goes out of scope. If you want that, simply write:

SomeType obj;

SomeType obj;

To copy to clipboard, switch view to plain text mode 

When the variable goes out of scope, the compiler will delete it for you.

There is also a chance you want a reference counting pointer:

SharedPtr ptr1 = new SomeType;
SharedPtr ptr2 = ptr1;
delete ptr1; // this is just an example...
ptr2->stillWorking();

SharedPtr ptr1 = new SomeType;
SharedPtr ptr2 = ptr1;
delete ptr1; // this is just an example...
ptr2->stillWorking();

To copy to clipboard, switch view to plain text mode 

In that case QSharedDataPointer (or rather QExplicitelySharedDataPointer) will be helpful if you implement SomeType as a shared class. Then you'll be able to write:

SomeType obj1;
SomeType obj2 = obj1;

SomeType obj1;
SomeType obj2 = obj1;

To copy to clipboard, switch view to plain text mode 

And both facade objects will point to the same set of data.

You might also want a guarded pointer (similar to what QMutexLocker does). In that case you can implement it yourself.

template <class T> class GuardedPtr {
public:
  GuardedPtr(T *o) { ptr = o; }
  ~GuardedPtr(){ delete ptr; }
private:
  T *ptr;
};

template <class T> class GuardedPtr {
public:
  GuardedPtr(T *o) { ptr = o; }
  ~GuardedPtr(){ delete ptr; }
private:
  T *ptr;
};

To copy to clipboard, switch view to plain text mode 

and then use it like this:

xyz *ptr = new xyz;
GuardedPtr<ptr> guard(ptr);
//...
// ptr gets deleted when guard goes out of scope

xyz *ptr = new xyz;
GuardedPtr<ptr> guard(ptr);
//...
// ptr gets deleted when guard goes out of scope

To copy to clipboard, switch view to plain text mode 

Just be aware it's a stupid class that may cause much trouble.

[ComaWhite]

I think I finally got it working. But I thought you would call detach before setting the value and not after?

#include <QExplicitlySharedDataPointer>
#include <QSharedData>
#include <QDebug>
 
class ValueData : public QSharedData {
public:
    ValueData()
        : m_value(1) {
    }
    ValueData(int value)
        : m_value(value) {
    }
    ~ValueData() { }
    ValueData(const ValueData& v)
        : QSharedData(v),
          m_value(v.m_value) {
    }
    void print() {
        qDebug() << m_value;
    }
 
    int m_value;
};
 
class ValueT {
public:
    ValueT() {
        d = new ValueData;
    }
 
    ValueT(int value) {
        d = new ValueData(value);
    }
 
    void setValue(int value) {
        d->m_value = value;
        d.detach();
    }
    void print() {
        d->print();
    }
private:
    QExplicitlySharedDataPointer<ValueData> d;
};

#include <QExplicitlySharedDataPointer>
#include <QSharedData>
#include <QDebug>

class ValueData : public QSharedData {
public:
    ValueData()
        : m_value(1) {
    }
    ValueData(int value)
        : m_value(value) {
    }
    ~ValueData() { }
    ValueData(const ValueData& v)
        : QSharedData(v),
          m_value(v.m_value) {
    }
    void print() {
        qDebug() << m_value;
    }

    int m_value;
};

class ValueT {
public:
    ValueT() {
        d = new ValueData;
    }

    ValueT(int value) {
        d = new ValueData(value);
    }
    
    void setValue(int value) {
        d->m_value = value;
        d.detach();
    }
    void print() {
        d->print();
    }
private:
    QExplicitlySharedDataPointer<ValueData> d;
};

To copy to clipboard, switch view to plain text mode 

But one last question. What happens if the end user does

ValueT* v = new ValueT(123);

ValueT* v = new ValueT(123);

To copy to clipboard, switch view to plain text mode 

Will it cause a a memory leak if s/he doesn't call delete?

[keeney]

Yes, then you must delete it yourself

[ComaWhite]

It doesn't like when you create your own operator= or copy constructor. Because I tried to make like 3 of them and when I did. It would never print to console unless I removed them

[wysota]

I think I finally got it working. But I thought you would call detach before setting the value and not after?

With an explicitely shared pointer you should call detach only if you want to separate the two objects (so copy is always a shallow copy by default). If you want to always separate them, use QSharedDataPointer which calls detach itself (copy on write).