Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.
Comment: Migration of unmigrated content due to installation of a new plugin
Znav
nextThe C++ Shared and SimpleShared Classes
prevThe C++ Handle Template Adaptors

IceUtil::ScopedArray is a smart pointer class similar to Handle. However, instead of managing the memory for class instances, ScopedArray manages memory for an array. This class is provided mainly for use with the stream API. However, you can use it with arrays for other purposes.

Here is the definition of the template in full:

Wiki Markup
{zcode:cpp}
template<typename T>
class ScopedArray : private IceUtil::noncopyable
{
public:
    explicit ScopedArray(T* ptr = 0)
        : _ptr(ptr) { }

    ScopedArray(const ScopedArray& other) {
        _ptr = other._ptr;
        const_cast<ScopedArray&>(other)._ptr = 0;
    }

    ~ScopedArray() {
        if (_ptr != 0)
            delete[] _ptr;
    }

    void reset(T* ptr = 0) {
        assert(ptr == 0 || ptr != _ptr);
        if (_ptr != 0)
            delete[] _ptr;
        _ptr = ptr;
    }

    T& operator[](size_t i) const {
        assert(_ptr != 0);
        assert(i >= 0);
        return _ptr[i];
    }

    T* get() const {
        return _ptr;
    }

    void swap(ScopedArray& a) {
        T* tmp = a._ptr;
        a._ptr = _ptr;
        _ptr = tmp;
    }

private:
    T* _ptr;
};
{zcode}

The class allows you to allocate an array on the heap and assign its pointer to a ScopedArray instance. When the instance goes out of scope, it calls delete[] on the array, so you do not need to deallocate the array explicitly yourself. This greatly reduces the risk of a memory leak due to an early return or uncaught exception.

Ztop
See Also
Zret
Znav
nextThe C++ Shared and SimpleShared Classes
prevThe C++ Handle Template Adaptors