Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Sequence Class

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
27.09.2006, 20:22 Uhr
mathon



Hallo,

Ich muss eine Sequence Klasse bauen, das header-file dafür ist vorgegeben:


Code:
class sequence
    {
    public:
        // TYPEDEFS and MEMBER CONSTANTS
        typedef double value_type;
        typedef std::size_t size_type;
        static const size_type DEFAULT_CAPACITY = 30;
        // CONSTRUCTORS and DESTRUCTOR
        sequence(size_type initial_capacity = DEFAULT_CAPACITY);
        sequence(const sequence& source);
        ~sequence( );
        // MODIFICATION MEMBER FUNCTIONS
        void resize(size_type new_capacity);
        void start( );
        void advance( ); //set the current_index to the next number in the array
        void insert(const value_type& entry); //insert before the number with the current index
        void attach(const value_type& entry); //insert after the number with the current index
        void remove_current( );
        void operator =(const sequence& source);
        // CONSTANT MEMBER FUNCTIONS
        size_type size( ) const;
        bool is_item( ) const;
        value_type current( ) const;
    private:
        value_type* data; //das array mit den zahlen drinnen
        size_type used; //wieviele zahlen in dem array stehen
        size_type current_index;
    size_type capacity;
    };



Leider stimmt bei mir beim copy-constructor anscheinend irgendwas nicht, aber ich komme einfach nicht drauf was hier falsch ist:

Code:
sequence::sequence(const sequence& source)
{
    data = new value_type[source.capacity];
    capacity = source.capacity;
    used = source.used;
    current_index = source.current_index;
    copy(source.data, source.data + used, data);
}



Hier auch noch die insert, attach und resize funktionen:

Code:

void sequence::insert(const value_type& entry)
{
    if(used == capacity)
        resize(used);

    if(!(is_item()))
        current_index = 0;

    for(int i = used; i > current_index; i--)
    {
        data[i] = data[i-1];
    }
    data[current_index] = entry;
    ++used;
}

void sequence::attach(const value_type& entry)
{
    if(used == capacity)
        resize(used);

    if(current_index >= used)
    {
        start();
        advance();
        advance();
    }
    if(used!=0)
    {
        for(int i = used; i > current_index+1; i--)
        {
            data[i] = data[i-1];
        }
        data[current_index+1] = entry;
        current_index++;
    }
    else
    {
        data[current_index] = entry;
    }
    ++used;
}

void sequence::resize (size_type new_capacity)
{
    value_type* larger_array;

    if(new_capacity < used)
        new_capacity = used;

    larger_array = new value_type[new_capacity];
    copy(data, data + used + current_index, larger_array);
    delete[] data;
    data = larger_array;
    capacity = new_capacity;
}



Hat irgendjemand von euch ne Ahnung was hier falsch läuft? - Ich arbeite daran jetzt schon solange daran und bin schon kurz vorm verzweifeln...

lg matti
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
27.09.2006, 21:19 Uhr
mathon



Hier ist das test-programm, das ich verwende:


C++:
int test5( )
{
    sequence original; // A sequence that we'll copy.
    double items[2*original.DEFAULT_CAPACITY];
    size_t i;

    // Set up the items array to conatin 1...2*DEFAULT_CAPACITY.
    for (i = 1; i <= 2*original.DEFAULT_CAPACITY; i++)
        items[i-1] = i;
    
    // Test copying of an empty sequence. After the copying, we change the original.
    cout << "Copy constructor test: for an empty sequence." << endl;
    sequence copy1(original);
    original.attach(1); // Changes the original sequence, but not the copy.
    if (!correct(copy1, 0, 0, items)) return 0;

    // Test copying of a sequence with current item at the tail.
    cout << "Copy constructor test: for a sequence with cursor at tail." << endl;
    for (i=2; i <= 2*original.DEFAULT_CAPACITY; i++)
        original.attach(i);
    cout << "SIZE: " << original.size() << endl;
    sequence copy2(original);
    original.start( );
    original.advance( );
    original.remove_current( ); // Removes 2 from the original, but not the copy.
    if (!correct
        (copy2, 2*original.DEFAULT_CAPACITY, 2*original.DEFAULT_CAPACITY-1, items)
        )
        return 0;

    // Test copying of a sequence with cursor near the middle.
    cout << "Copy constructor test: for a sequence with cursor near middle." << endl;
    original.insert(2);
    for (i = 1; i < original.DEFAULT_CAPACITY; i++)
        original.advance( );
    // Cursor is now at location [DEFAULT_CAPACITY] (counting [0] as the first spot).
    sequence copy3(original);
    original.start( );
    original.advance( );
    original.remove_current( ); // Removes 2 from the original, but not the copy.
    if (!correct
        (copy3, 2*original.DEFAULT_CAPACITY, original.DEFAULT_CAPACITY, items)
        )
        return 0;

    // Test copying of a sequence with cursor at the front.
    cout << "Copy constructor test: for a sequence with cursor near middle." << endl;
    original.insert(2);
    original.start( );
    // Cursor is now at the front.
    sequence copy4(original);
    original.start( );
    original.advance( );
    original.remove_current( ); // Removes 2 from the original, but not the copy.
    if (!correct
        (copy4, 2*original.DEFAULT_CAPACITY, 0, items)
        )
        return 0;

    // Test copying of a sequence with no current item.
    cout << "Copy constructor test: for a sequence with no current item." << endl;
    original.insert(2);
    while (original.is_item( ))
        original.advance( );
    // There is now no current item.
    sequence copy5(original);
    original.start( );
    original.advance( );
    original.remove_current( ); // Removes 2 from the original, but not the copy.
    if (!correct
        (copy5, 2*original.DEFAULT_CAPACITY, 2*original.DEFAULT_CAPACITY, items)
        )
        return 0;
}



Nach der Zeile cout << "Copy constructor test: for a sequence with cursor near middle." << endl; bricht das Programm ab und es erscheint ein Popup-Fenster, wo steht, dass das Programm einen Fehler festgestellt hat und beendet werden musste.

Ich glaube der Fehler passiert eigentlich bei dem insert statement danach.

Hat jemand von euch ne ahnung..? :confused:

matti

Dieser Post wurde am 27.09.2006 um 22:16 Uhr von FloSoft editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
27.09.2006, 21:30 Uhr
xXx
Devil


kennst du debuggen?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
27.09.2006, 22:09 Uhr
mathon



ja schon, ich habe eh versucht mit cout-statements auf den fehler draufzukommen, aber ich finde den fehler einfach nicht...
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
27.09.2006, 22:21 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


benutz nen debugger z.b gdb und lass dir ausgeben wo genau er spuckt . ich schätz mal das es irgendwo ne av gibt ansonsten ist die resizemethode irgendwie schrott. ich würde nur resizen wenn man nicht genügend platz hat - also evtl noch speichern wieviel platz man alloziiert hat und wieviel benutzt ist. dann kann man da akkurat vergrößern - verkleinern muss ja normalerweise nicht sein. Weiterhin würde ich einfach ein template draus machen - das typedef-zeug ist imho so schwachsinn - template macht da um einiges mehr sinn.
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
27.09.2006, 22:59 Uhr
mathon



ich weiß genau wo er spuckt und das ist beim insert hier:


Code:
cout << "Copy constructor test: for a sequence with cursor near middle." << endl;
original.insert(2);



Ich krieg da eine bad_alloc exception beim debuggen aber ich weiß nicht wo ich da über den heap hinausschreiben würde...

in der resize-methode gehört natürlich das current_index in der copy methode weg, ansonsten passt die meiner meinung nach so, die resize methode wird ja nur aufgerufen, wenn das gegenwärtige array zu klein ist.

hier sind die anderen methoden von der sequenceimpl:

Code:
sequence::sequence(size_type initial_capacity)
{
    data = new value_type[initial_capacity];
    capacity = initial_capacity;
    used = 0;
    current_index = 0;
}

sequence::~sequence()
{
    delete[] data;
}

void sequence::operator = (const sequence& source)
{
    value_type* new_data;

    if (this == &source)
        return;

    if(capacity != source.capacity)
    {
        new_data = new value_type[source.capacity];
        delete[] data;
        data = new_data;
        capacity = source.capacity;
    }

    used = source.used;
    current_index = source.current_index;
    copy(source.data, source.data + used, data);
}

void sequence::start( )
{
    current_index = 0;
}

void sequence::advance( )
{
    if(is_item())
        current_index++;
}

void sequence::remove_current( )
{
    //cout << current_index << " " << used;
    for(int i = current_index; i < used; i++)
    {
        data[i] = data[i+1];
    }
    used--;
    
}

sequence::value_type sequence::current() const
{
    return data[current_index];    
}

bool sequence::is_item( ) const
{
    if(current_index < used)
    {
        return true;
    }
    else
    {
        return false;
    }
}

sequence::size_type sequence::size() const
{
    return used;
}



hast du vielleicht noch eine idee...?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: