[C++]Stack implementatie: eerst twee geheugenadressen, dan pas waarden

[Joshua822]

Hallo allemaal.

Ik ben bezig met een implementatie van ( mijn begrip van ) een stack ( ja, het werkt nog niet als een echte stack, vooral omdat de functies stack_push ( ) en stack_pop nog niet volledig zijn ).

Het prboleem is dat ik als output dit wil verkrijgen:

Code: [Selecteer]

17
9
...
...
...
Maar dat ik als output het volgende krijg:

Code: [Selecteer]

3990072
3990072
17
9
...
...
Hier is de code, ik denk wel dat jullie zullen begrijpen wat ik voor elkaar wil krijgen. Zo niet, vraag het dan, dan zal ik het uitgebreider proberen uit te leggen.

Code: [Selecteer]

#include <iostream>
#include <new>

using namespace std;

int * stack_create ( int size );
void stack_push ( int * stack, int stack_size, int val );
int stack_pop ( int * stack, int stack_size );
void stack_delete ( int * stack );
void print_stack ( int * stack, int stack_size );

int main ( )
{
    int * pstack;
    pstack = stack_create ( 18 );
    stack_push ( pstack, 18, 17 );
    stack_push ( pstack, 18, 9 );
    print_stack ( pstack, 18 );
    stack_delete ( pstack );
    cin.get ( );
    return 0;
}

int n;

int * stack_create ( int size )
{
    int * new_stack = new int [ size ]; return new_stack;
}
void stack_push ( int * stack, int stack_size, int val )
{
     for ( n = 0; n < stack_size; n++ )
     {
         if ( stack [ n ] == 0 )
         {
              stack [ n ] = val;
              break;
         }
     }
}
int stack_pop ( int * stack, int stack_size )
{
    for ( n = 0; n < stack_size; n++ )
    {
        if ( stack [ n ] == 0 )
            break;
        else
        {
            return stack [ n ];
        }
    } 
}
void stack_delete ( int * stack )
{
     delete [ ] stack;
}
void print_stack ( int * stack, int stack_size )
{
     int n;
     for ( n = 0; n < stack_size; n++ )
         cout << stack [ n ] << endl;
}
Alvast bedankt

[Joshua822]

Niemand?

Ik heb de stack qua functionaliteit bijna afgewerkt. ook heb ik een workaround gevonden voor het "eerst twee geheugenadressen" probleem. Maar toch hoop ik dat iemand mij nog steeds naar de fout wijst; nu verspil ik gewoon onterecht 8 bytes.

Maar goed, hier is de nieuwe code:

Code: [Selecteer]

#include <iostream>
#include <new>

using namespace std;

int * stack_create ( int size );
void stack_push ( int * stack, int stack_size, int val );
int stack_pop ( int * stack, int stack_size );
void stack_delete ( int * stack );
void print_stack ( int * stack, int stack_size );

int main ( )
{
    int * pstack;
    int val_popped;
    pstack = stack_create ( 7 );
    stack_push ( pstack, 7, 5 );
    stack_push ( pstack, 7, 16 );
    stack_push ( pstack, 7, 33 );
    stack_push ( pstack, 7, 44 );
    stack_push ( pstack, 7, 83 );
    val_popped = stack_pop ( pstack, 7 );
    print_stack ( pstack, 7 );
    cout << "\n" << val_popped << endl;
    stack_delete ( pstack );
    cin.get ( );
    return 0;
}

int n;

int * stack_create ( int size )
{
    int * new_stack = new int [ size + 2 ]; return new_stack;
}
void stack_push ( int * stack, int stack_size, int val )
{
     if ( stack [ stack_size + 2 ] != 0 )
          cout << "Fout: de stack is vol." << endl;
     for ( n = 2; n < ( stack_size + 2 ); n++ )
     {
         if ( stack [ n ] == 0 )
         {
              stack [ n ] = val;
              break;
         }
     }
}
int stack_pop ( int * stack, int stack_size )
{
    for ( n = stack_size + 2; n >= 0; n-- )
    {
        if ( stack [ n ] != 0 )
             return stack [ n ];
        else if ( stack == 0 )
             return 0;
    }
}
void stack_delete ( int * stack )
{
     delete [ ] stack;
}
void print_stack ( int * stack, int stack_size )
{
     int n;
     for ( n = 2; n < ( stack_size + 2 ); n++ )
         cout << stack [ n ] << endl;
}

[SeySayux]

std::stack?

Nee, serieus, waarom gebruik je geen klasse?

Code: [Selecteer]

template<class T>
class Stack {
public:
    Stack(size_t _size = 16) : size(_size), buf(new T[size]), idx(0) {}
    virtual ~Stack() { delete[] buf; }
    void push(const T& t) { buf[idx++] = t;}
    T pop() {
        T toreturn = buf[idx];
        buf[idx--].~T();
        return toreturn;
    }
private:
    size_t size;
    T * buf;
    size_t idx;
};
Dit is nog maar zeer primitief, waarschijnlijk wil je ook nog een overflow check, etc... Kijk even naar Sylph::Vector of zo... Of wacht, wacht tot versie 0.2 en kijk dan naar Sylph::Vector

[Joshua822]

Zoals ik al eerder zij, ik hou er gewoon van om zoveel mogelijk met mijn beperkte kennis te doen. Ik hou ervan om mijn eigen functies te schrijven voor iets waar ik eigenlijk een class voor kan gebruiken. Dat is gewoon leuk en leerzaam.

Dus, toch zeer bedankt voor je antwoord, maar ik zou toch liever willen weten waar die fout zit in mijn implementatie.

Trouwens, mijn huidige implementatie met overflow bescherming:

Code: [Selecteer]

#include <iostream>
#include <new>

using namespace std;

int * stack_create ( int size );
void stack_push ( int * stack, int stack_size, int val );
int stack_pop ( int * stack, int stack_size );
void stack_delete ( int * stack );
void print_stack ( int * stack, int stack_size );

int main ( )
{
    int * pstack;
    int val_popped;
    pstack = stack_create ( 7 );
    stack_push ( pstack, 7, 5 );
    stack_push ( pstack, 7, 16 );
    stack_push ( pstack, 7, 33 );
    stack_push ( pstack, 7, 44 );
    stack_push ( pstack, 7, 83 );
    stack_push ( pstack, 7, 89 );
    stack_push ( pstack, 7, 91 );
    val_popped = stack_pop ( pstack, 7 );
    print_stack ( pstack, 7 );
    cout << "\n" << val_popped << endl;
    stack_delete ( pstack );
    cin.get ( );
    return 0;
}

int n;

int * stack_create ( int size )
{
    int * new_stack = new int [ size + 2 ]; return new_stack;
}
void stack_push ( int * stack, int stack_size, int val )
{
     if ( stack [ stack_size + 2 ] != 0 )
     {     
          #define STACK_FULL 1
          cout << "Fout: de stack is vol." << endl;     
     }
     #ifndef STACK_FULL_1
     for ( n = 2; n < ( stack_size + 2 ); n++ )
     {
         if ( stack [ n ] == 0 )
         {
              stack [ n ] = val;
              break;
         }
     }
     #endif
}
int stack_pop ( int * stack, int stack_size )
{
    for ( n = stack_size + 2; n >= 0; n-- )
    {
        if ( stack [ n ] != 0 )
             return stack [ n ];
        else if ( stack == 0 )
             return 0;
    }
}
void stack_delete ( int * stack )
{
     delete [ ] stack;
}
void print_stack ( int * stack, int stack_size )
{
     int n;
     for ( n = 2; n < ( stack_size + 2 ); n++ )
         cout << stack [ n ] << endl;
}
Ik heb het getest, en het werkt. Alleen geeft hij geen foutmelding weer. Wat zijn preprocessor directives toch handig