stack

Hvis din kode virker som den er nu (hvor den returnerer en kopi af top-elementet), så er det bare at ændre typen af top, både i .h-filen og i .template filen.

Med andre ord:

namespace main_savitch_7B
{
    template <class Item>
    class stack
    {
    public:
        // Meget slettet
        Item& top( ) const;
    private:
        main_savitch_6B::node<Item> *top_ptr;  // Points to top of stack
    };
}

namespace main_savitch_7B
{
    // Meget slettet
    template <class Item>
    Item& stack<Item>::top( ) const
    // Library facilities used: cassert
    {
        assert(!empty( ));
        return top_ptr->data( );
    }
}

Og hvordan tester du så om det virker?

#include <stack2.h>

int main() {
  stack<int> my_stack;
  my_stack.push(1);
  // Check at my_stack.top() == 1
  my_stack.top() = 7;
  // Check at my_stack.top() == 7
  return 0;
}

Det at du både skal kunne checke top() og ændre i den gør at du faktisk har brug for top() i to udgaver. Både med og uden &, og lad være med at lave den const når den er med &.

}

Tak for dit svar, imponerende hurtigt. Jeg sidder lige med et andet project som har drillet i timevis, saa jeg vil vende tilbare senere, naar jeg har faaet kigget paa dit svar.
Endnu engang tak

Det virker desvarre ikke. Kan du muligvis compile det og de hvad der sker. Jeg har pasted to filer ind som ikke var med i foerste omgang, saa programmet skulle vaere klar til dig.
Jeg haaber at du kan finde fejlen.
Tak igen ;-)


node2.h refererer til denne fil:

#ifndef MAIN_SAVITCH_NODE2_H 
#define MAIN_SAVITCH_NODE2_H
#include <cstdlib>  // Provides NULL and size_t
#include <iterator>  // Provides iterator and forward_iterator_tag

namespace main_savitch_6B
{
    template <class Item>
    class node
    {
    public:
        // TYPEDEF
        typedef Item value_type;
        // CONSTRUCTOR
        node(const Item& init_data=Item( ), node* init_link=NULL)
            { data_field = init_data; link_field = init_link; }
        // MODIFICATION MEMBER FUNCTIONS
        Item& data( ) { return data_field; }
        node* link( ) { return link_field; }
        void set_data(const Item& new_data) { data_field = new_data; }
        void set_link(node* new_link) { link_field = new_link; }
        // CONST MEMBER FUNCTIONS
        const Item& data( ) const { return data_field; }
        const node* link( ) const { return link_field; }
    private:
        Item data_field;
        node *link_field;
    };

    // FUNCTIONS to manipulate a linked list:
    template <class Item>
    void list_clear(node<Item>*& head_ptr);

    template <class Item>
    void list_copy
        (const node<Item>* source_ptr, node<Item>*& head_ptr, node<Item>*& tail_ptr);

    template <class Item>
    void list_head_insert(node<Item>*& head_ptr, const Item& entry);

    template <class Item>
    void list_head_remove(node<Item>*& head_ptr);

    template <class Item>
    void list_insert(node<Item>* previous_ptr, const Item& entry);

    template <class Item>
    size_t list_length(const node<Item>* head_ptr);

    template <class NodePtr, class SizeType>
    NodePtr list_locate(NodePtr head_ptr, SizeType position);

    template <class Item>
    void list_remove(node<Item>* previous_ptr);
 
    template <class NodePtr, class Item>
    NodePtr list_search(NodePtr head_ptr, const Item& target);

    // FORWARD ITERATORS to step through the nodes of a linked list
    // A node_iterator of can change the underlying linked list through the
    // * operator, so it may not be used with a const node. The
    // node_const_iterator cannot change the underlying linked list
    // through the * operator, so it may be used with a const node.
    // WARNING:
    // This classes use std::iterator as its base class;
    // Older compilers that do not support the std::iterator class can
    // delete everything after the word iterator in the second line:

    template <class Item>
    class node_iterator
    : public std::iterator<std::forward_iterator_tag, Item>
    {
    public:
        node_iterator(node<Item>* initial = NULL)
        { current = initial; }
    Item& operator *( ) const
        { return current->data( ); }
    node_iterator& operator ++( ) // Prefix ++
        {
        current = current->link( );
        return *this;
        }
    node_iterator operator ++(int) // Postfix ++
        {
        node_iterator original(current);
        current = current->link( );
        return original;           
        }
    bool operator ==(const node_iterator other) const
        { return current == other.current; }
    bool operator !=(const node_iterator other) const
        { return current != other.current; }
    private:
    node<Item>* current;
    };

    template <class Item>
    class const_node_iterator
    : public std::iterator<std::forward_iterator_tag, const Item>
    {
    public:
        const_node_iterator(const node<Item>* initial = NULL)
        { current = initial; }
    const Item& operator *( ) const
        { return current->data( ); }
    const_node_iterator& operator ++( ) // Prefix ++
        {
        current = current->link( );
        return *this;
        }
    const_node_iterator operator ++(int) // Postfix ++
        {
        const_node_iterator original(current);
        current = current->link( );
        return original;
        }
    bool operator ==(const const_node_iterator other) const
        { return current == other.current; }
    bool operator !=(const const_node_iterator other) const
        { return current != other.current; }
    private:
    const node<Item>* current;
    };

}

#include "node2.template"
#endif

node2.template refererer til denne fil:
// FILE: node2.template
// IMPLEMENTS: The functions of the node template class and the
// linked list toolkit (see node2.h for documentation).
//
// NOTE:
//  Since node is a template class, this file is included in node2.h.
//  Therefore, we should not put any using directives in this file.
//
// INVARIANT for the node class:
//  The data of a node is stored in data_field, and the link in link_field.

#include <cassert>    // Provides assert
#include <cstdlib>    // Provides NULL and size_t

namespace main_savitch_6B
{
    template <class Item>
    void list_clear(node<Item>*& head_ptr)
    // Library facilities used: cstdlib
    {
    while (head_ptr != NULL)
        list_head_remove(head_ptr);
    }

    template <class Item>
    void list_copy(
    const node<Item>* source_ptr,
    node<Item>*& head_ptr,
    node<Item>*& tail_ptr
    )
    // Library facilities used: cstdlib
    {
    head_ptr = NULL;
    tail_ptr = NULL;

    // Handle the case of the empty list
    if (source_ptr == NULL)
        return;   

    // Make the head node for the newly created list, and put data in it
    list_head_insert(head_ptr, source_ptr->data( ));
    tail_ptr = head_ptr;
   
    // Copy rest of the nodes one at a time, adding at the tail of new list
    source_ptr = source_ptr->link( );
        while (source_ptr != NULL)
    {
        list_insert(tail_ptr, source_ptr->data( ));
        tail_ptr = tail_ptr->link( );
        source_ptr = source_ptr->link( );
    }
    }
   
    template <class Item>
    void list_head_insert(node<Item>*& head_ptr, const Item& entry)
    {
    head_ptr = new node<Item>(entry, head_ptr);
    }

    template <class Item>
    void list_head_remove(node<Item>*& head_ptr)
    {
    node<Item> *remove_ptr;

    remove_ptr = head_ptr;
    head_ptr = head_ptr->link( );
    delete remove_ptr;
    }

    template <class Item>
    void list_insert(node<Item>* previous_ptr, const Item& entry)
    {
    node<Item> *insert_ptr;
   
    insert_ptr = new node<Item>(entry, previous_ptr->link( ));
    previous_ptr->set_link(insert_ptr);
    }

    template <class Item>
    size_t list_length(const node<Item>* head_ptr)
    // Library facilities used: cstdlib
    {
    const node<Item> *cursor;
    std::size_t answer;
   
    answer = 0;
    for (cursor = head_ptr; cursor != NULL; cursor = cursor->link( ))
        ++answer;
   
    return answer;
    }

    template <class NodePtr, class SizeType>
    NodePtr list_locate(NodePtr head_ptr, SizeType position)
    // Library facilities used: cassert, cstdlib
    {
    NodePtr cursor;
    SizeType i;
   
    assert(0 < position);
    cursor = head_ptr;
    for (i = 1; (i < position) && (cursor != NULL); ++i)
        cursor = cursor->link( );
    return cursor;
    }

    template <class Item>
    void list_remove(node<Item>* previous_ptr)
    {
    node<Item> *remove_ptr;

    remove_ptr = previous_ptr->link( );
    previous_ptr->set_link(remove_ptr->link( ));
    delete remove_ptr;
    }

    template <class NodePtr, class Item>
    NodePtr list_search(NodePtr head_ptr, const Item& target)
    // Library facilities used: cstdlib
    {
    NodePtr cursor;
   
    for (cursor = head_ptr; cursor != NULL; cursor = cursor->link( ))
        if (target == cursor->data( ))
        return cursor;
    return NULL;
    }
}

Hvad mener du med virker ikke? Kan det ikke oversætte, eller giver det et andet resultat end du forventer?

Der er problemer med at .cpp filen. Foelgende fejl forekommer:
:\Documents and Setting\stack2.cpp(10) : error C2065: 'stack' : undeclared identifier
C:\Documents and Settings\stack2.cpp(10) : error C2062: type 'int' unexpected
C:\Documents and Settings\stack2.cpp(11) : error C2065: 'my_stack' : undeclared identifier
C:\Documents and Settings\stack2.cpp(11) : error C2228: left of '.push' must have class/struct/union type
C:\Documents and Setting\stack2.cpp(13) : error C2228: left of '.top' must have class/struct/union type
Error executing cl.exe.

stack2.obj - 5 error(s), 0 warning(s)

Du har copy&pasted node2.h og node2.template, ikke? Men jeg vil også gerne se stack2.cpp, for det er der din oversætter finder fejlene.

Hvis du har copy&pasted mit forslag til en test (og det er det jeg gætter der sker), så mangler du sandsynligvis (i hvert fald)

using main_savitch_7B::stack; i stack2.cpp.

Det hjalp, men jeg sidder stadigvaek med denne fejl:
c:\documents and settings\stack2.h(62) : error C2065: 'list_clear' : undeclared identifier

ja, jeg brugte dit forslag til test bare for at svare paa dit forrige spoergsmaal

list_clear kan jeg ikke se i noget af den kode du har pastet, så du kommer nok til at smide lidt mere ind. Det lader til at du prøver at bruge noget der hedder list_clear, som ikke er defineret nogetsteds.

Opgaven blev afleveret igaar og jeg er noedsaget til at arbejde paa mine andre 5 fag, saa jeg har maattet acceptere at jeg ikke finder ud af fejlen i foerste omgang.
Tak for hjaelpen, den har vaeret god

Tak for point!

Jeg er nu alligevel nysgerrig over at se den del af koden hvor du bruger list_clear.