My test code looks like this:

-----------------------------------------------------------------
    KDOM::SharedVector<ItemType *> v2;
    {
        Q_ASSERT(BuiltinTypes::xsDouble);
        Q_ASSERT(BuiltinTypes::xsInteger);
        KDOM::SharedVector<ItemType *> v1(2);
        v1.insert(0, BuiltinTypes::xsDouble);
        v1.insert(1, BuiltinTypes::xsInteger);
        CHECK(v1.count(), static_cast<size_t>(2));
        CHECK(v1.at(0)->xdtMatchesType(BuiltinTypes::xsDouble), true);
        CHECK(v1.at(1)->xdtMatchesType(BuiltinTypes::xsInteger), true);

        v1 = v2;
    }


    CHECK(v2.count(), static_cast<size_t>(2));
    Q_ASSERT(v2.at(0)); /* CRASH, gdb reports SIGSEGV, valgrind says "Invalid read of size 4 [...] Address 0x0 is not stack'd, malloc'd or (recently) free'd" */
-----------------------------------------------------------------


All tests works up until the Q_ASSERT, where it crashes. Valgrind reports the address "0x0", but if the value at position 0(which the at() function should return) is 0, the assert should fail(print message), but not crash, AFAICT.

The SharedVector class looks like this:


-----------------------------------------------------------------
	template<typename T> class SharedVector : public QValueVector<T>
	{
	public:

		SharedVector(typename QValueVector<T>::size_type n, const T& val = T()) : QValueVector<T>(n, val)
		{
		}

		SharedVector(const SharedVector<T> & l) : QValueVector<T>(l)
		{
			typename SharedVector<T>::const_iterator it;
			typename SharedVector<T>::const_iterator end(l.constEnd());

			for(it = l.constBegin(); it != end; ++it)
			{
				Q_ASSERT((*it));
				if(*it)
					(*it)->ref();
			}
		}

		SharedVector() : QValueVector<T>()
		{
		}

		virtual ~SharedVector()
		{
			clear();
		}

		virtual void clear()
		{
			typename SharedVector<T>::iterator it;

			for(it = begin(); it != end(); ++it)
				if((*it))
					(*it)->deref();

			QValueVector<T>::clear();
		}

		virtual void append(const T item)
		{
			Q_ASSERT(item);
			if(!item)
				return;

			const_cast<T>(item)->ref();

			QValueVector<T>::append(item);
		}

		void insert(typename QValueVector<T>::size_type pos, const T& x)
		{
			T item = QValueVector<T>::operator[](pos);

			if(item)
				item->deref();

			Q_ASSERT(x);
			x->ref();
			QValueVector<T>::operator[](pos) = x;
		}

		SharedVector<T>& operator+=(const SharedVector<T>& l)
		{
			typename SharedVector<T>::const_iterator it;
			typename SharedVector<T>::const_iterator end(l.constEnd());

			for(it = l.constBegin(); it != end; ++it)
				append((*it));

			return *this;
		}

		SharedVector<T>& operator=(const SharedVector<T>& l)
		{
			kdDebug(26560) << k_funcinfo << endl;
			typename SharedVector<T>::const_iterator it;
			typename SharedVector<T>::const_iterator end(l.constEnd());

			for(it = l.constBegin(); it != end; ++it)
			{
				Q_ASSERT((*it));
				if(*it)
					(*it)->ref();
			}

			QValueVector<T>::operator=(l);
			return *this;
		}

	protected:

		/**
		 * Overriden as protected, such that reference counting is handled
		 * properly. Use insert() instead.
		 */
		typename QValueVector<T>::reference operator[](typename QValueVector<T>::size_type s)
		{
			return QValueVector<T>::operator[](s);
		}

	};
};