Schwierigkeiten mit Klasse und dynamischen Array

[devDevil]

(1) #pragma comment erlaubt es das ganze etwas zu beschleunigen, aber im Grunde ist das Verhalten das eines Include-Guards.
(2) Die Funktion ist überflüssig, aber wo ich schon nen Namensraum draus gemacht hab wollt ich's vollständig haben und normal sollte man die beiden Funktionen (inkl. namespace) dann in einen extra Header packen.
(3) Ehm das ist ganz einfach. std::list<T> hat ein Typedef nahmens value_type, dass eben genau dieses T ist . Demnach wird dann std::list<int*>::value_type zu int* aufgelöst ... Das ist auch der Grund der Namensvergabe bei DynArray

So bei dem Code fehlten doch nur paar ')' und noch ein const_iterator. Eh und bei ostream war out und " " vertauscht Aber hey ich weiß auch nicht alle Parameter von irgendwelchen std.-Methoden auswendig

#if !defined DYNARRAY_HPP__INCLUDED
#define DYNARRAY_HPP__INCLUDED
 
#pragma once
 
#include <iostream>
#include <list>
#include <stdexcept>
#include <algorithm>
#include <iterator>
 
namespace memory
{
    template <typename _PtrT>
    inline void safe_delete_arr(_PtrT& ptr)
    {
         delete [] ptr;
         ptr = NULL;
    }
 
    template <typename _PtrT>
    inline void safe_delete_ptr(_PtrT& ptr)
    {
        delete ptr;
        ptr = NULL;
    }
}; // memory
 
template<typename _ValueT, int PartSize = 20>
class DynArray
{
public:
    typedef _ValueT value_type;
    typedef std::list<value_type*> storage_type;
    typedef std::size_t size_type;
    
    DynArray()
        : m_index(0), m_data(new value_type[PartSize])
    {}
 
    ~DynArray()
    {
        if (!m_storage.empty())
			std::for_each(m_storage.begin(), m_storage.end(), memory::safe_delete_arr<typename storage_type::value_type>);
        memory::safe_delete_arr(m_data);
    }
 
    const size_type size() const { return (m_storage.size() * PartSize + m_index); }
    value_type& operator[](const std::size_t rhs)
    {
        if (rhs >= size()) throw std::out_of_range("index");
        if (rhs > (size() - m_index)) return m_data[rhs % PartSize];
         
        storage_type::const_iterator it(m_storage.begin());
        std::advance(it, static_cast<std::size_t>(rhs / PartSize));
        return (*it)[rhs % PartSize];
    }
    
    void insert(value_type const& value)
    {
        if (m_index >= PartSize)
        {
            m_storage.push_back(m_data);
            m_data = new value_type[PartSize];
            m_index = 0;
        }
        m_data[m_index++] = value;
    }
    template<typename _ValueT, int PartSize>
    friend std::ostream& operator<< (std::ostream& out, DynArray<_ValueT, PartSize> const& rhs)
    {
        DynArray<_ValueT, PartSize>::storage_type const& storage(rhs.m_storage);
        if (!storage.empty())
		{
			for (DynArray<_ValueT, PartSize>::storage_type::const_iterator it(storage.begin()); it != storage.end(); ++it)
            {
				std::copy(*it, (*it) + PartSize, std::ostream_iterator<_ValueT>(out, " "));
                out << "\n";
            }
		}
		std::copy(rhs.m_data, rhs.m_data + rhs.m_index, std::ostream_iterator<_ValueT>(out, " "));
        return out;
    }
 
private:
    storage_type m_storage;
    size_type m_index;
    typename storage_type::value_type m_data;
};
 
#endif // DYNARRAY_HPP__INCLUDE

So sollte das eigtl. ganz gut funktionieren

Probleme:
(1) Es fehlt eine Iterator-Klasse (sonst kommst de mit std.-Funktionen nichtmehr weit)
(2) Es müssen alle const-Versionen von operator[] und at usw. noch geschrieben werden.
(3) stream-oeprator hat da eigtl. nicht's zu suchen. (local, usw.) sondern lieber (1)

 

[Online-Skater]

Hehe, also ich benutze Code::Blocks mit gcc.

F:\Projects\C++\test\test.h|69|error: declaration of `class _ValueT'|
F:\Projects\C++\test\test.h|29|error:  shadows template parm `class _ValueT'|
F:\Projects\C++\test\test.h|69|error: declaration of `int PartSize'|
F:\Projects\C++\test\test.h|29|error:  shadows template parm `int PartSize'|
F:\Projects\C++\test\test.h||In member function `_ValueT& DynArray<_ValueT, PartSize>::operator[](size_t)':|
F:\Projects\C++\test\test.h|54|error: expected `;' before "it"|
F:\Projects\C++\test\test.h|55|error: `it' undeclared (first use this function)|
F:\Projects\C++\test\test.h|55|error: (Each undeclared identifier is reported only once for each function it appears in.)|
F:\Projects\C++\test\test.h|55|error: no matching function for call to `advance(<type error>, size_t&)'|
F:\Projects\C++\test\test.h||In function `std::ostream& operator<<(std::ostream&, const DynArray<_ValueT, PartSize>&)':|
F:\Projects\C++\test\test.h|72|error: expected `;' before "const"|
F:\Projects\C++\test\test.h|73|error: `storage' undeclared (first use this function)|
F:\Projects\C++\test\test.h|75|error: expected `;' before "it"|
F:\Projects\C++\test\test.h|75|error: `it' undeclared (first use this function)|
||=== Build finished: 12 errors, 0 warnings ===|

Zeile 54 wird ja durch die typedef Anweisung ersetzt zu: std::list<value_type*>::const_iterator it(m_storage.begin());
Das ist das Problem was ich habe

Vielen Dank für deine Mühe