Problem mit Zeiger-Ablagen. (Ablage1 in Ablage2 kopieren)

Aufgabe ist es eine Ablage zu programmieren und diese mit beliebig vielen Werten zu fuellen. Nach dem fuellen soll die Ablage in eine Ablage2 kopiert werden.
Nach dem kopieren sollen die Werte in Ablage 2 genau so angeordnet sein wie in Ablage1.
Das alles soll OOP sein.
Ich habe das Grundkonstrukt hinbekommen und kann auch Werte auf die Ablage legen.
Nur wenn er in die Funktion kopieren bricht die ausfuehrung des Programms ab und es steht RUN FAILED im output Fenster.
Ich weiß nicht was ich da noch aendern kann damit es ordentlich funktioniert.

Das ist die main.cpp:

/* 
 * File:   main.cpp
 * Author: admin
 *
 * Created on 6. Januar 2014, 23:27
 */

#include <cstdlib>
#include <iostream>
#include "Knoten.h"
using namespace std;
void copy (Knoten ablage, Knoten abl2, int anzknoten);

int main(int argc, char** argv) {
    Knoten ablage;
    //Abfrage der Anzahl an knoten und der befuellung
    int anzknoten, wert;
    cout << "Wieviele Werte sollen auf die Ablage?: ";
    cin >> anzknoten;
    for (int i=0; i<anzknoten; i++) {
        cout << "Integer eingeben: ";
        cin >> wert;
        ablage.drauflegen(wert);
    }
    Knoten abl2;
    copy(ablage, abl2, anzknoten);
    return 0;
}

void copy (Knoten ablage, Knoten abl2, int anzknoten) {
    Knoten *ablnew = new Knoten;
    ablnew = &ablage;
    Knoten *abl2new = new Knoten;
    abl2new = &abl2;
    int tmp ;

    for (int i=0; i<anzknoten; i++) {
        tmp = ablnew->copybegin->info;

        abl2new->info = tmp;

        ablnew = (*ablnew).next;
        abl2new = (*abl2new).next;
    }
}

Hier ist die Klasse Knoten.h
Ich habe sie Knoten genannt (wegen den einzelnen Bloecke/Knoten in der Ablage).

/* 
 * File:   Knoten.h
 * Author: admin
 *
 * Created on 7. Januar 2014, 23:35
 */

#ifndef KNOTEN_H
#define	KNOTEN_H
#include <iostream>
using namespace std;

class Knoten {
public:
    Knoten();
    Knoten(const Knoten& orig, Knoten ablage, Knoten abl2, int anzknoten);
    virtual ~Knoten();
    void drauflegen(int wert);
    int top();
    Knoten *copybegin = NULL;
    Knoten *oben = NULL;
    Knoten *next;
    int cnt = 0;
    int info;

private:   
};

#endif	/* KNOTEN_H */

Und letztes ist die Knoten.cpp

/* 
 * File:   Knoten.cpp
 * Author: admin
 * 
 * Created on 7. Januar 2014, 23:35
 */

#include "Knoten.h"
#include <iostream>

Knoten::Knoten() {
}

Knoten::Knoten(const Knoten& orig, Knoten ablage, Knoten abl2, int anzknoten) {  
}

Knoten::~Knoten() {
}

void Knoten::drauflegen(int wert) {

    Knoten *p = new Knoten;
    p->info = wert;
    p->next = oben;

    oben = p;
    if (cnt == 0) {
        copybegin = p;
    }
    cout << "p: " << p->info << endl;
    cout << "oben: " << oben->info << endl;
    cout << "copybegin: " << copybegin->info << endl << endl;
    cnt++;
}

int Knoten::top() {
    return oben->info;
}

SeppJ

Da sind einige Fehler drin, aber bevor ich die aufzähle: Wesentlich einfacher als eine verkettete Liste (das soll eine verkettete Liste sein, oder? Ich bin mir nämlich nicht ganz sicher) wäre es, den Stack mittels eines vectors zu implementieren. Ein selbstgeschriebener vector, da dies ja hier anscheinend die Aufgabe ist die Standardbibliothek nach zu programmieren , aber ein vector ist eben wesentlich unkomplizierter als eine Liste und kann ohne große Schwierigkeit in 20-30 Zeilen implementiert werden.

Bei deinem eigenen Versuch hast du mindestens schon einmal die Regel der großen Drei verletzt. Und überhaupt sind da ein paar sehr komische Designentscheidungen (Fehler?) drin:
-Wieso muss der Zuweisungsfunktion (Dein copy. Doofer Name. Nenn es doch operator= ) die Anzahl der Elemente mitgegeben werden? Die ergibt sich doch schon aus dem Inhalt der Liste. Oder sollte es. Wenn nicht, dann solltest du das ändern.
-Wieso ist ein Knoten auch gleichzeitig eine Liste? Was sollen die verschiedenen Member machen? Die Hälfte davon scheint sich auf die Aufgabe eines Listenknotens zu beziehen, die andere Hälfte auf die Aufgabe einer Liste.
-Die ganze Funktion copy: Was soll da eigentlich von wo nach wo kopiert werden? Von der Signatur her wohl ablage in ab12. Aber was soll dann der quatsch mit den temporären Knoten?
-Die Konstruktoren machen komische Sachen. Nämlich nichts. Wozu sind sie dann da?
-Damit will ich nicht sagen, dass du die Konstruktoren entfernen solltest. Sie sollen sicherlich was machen bei einer Liste. Die Datenstruktur bedarf ja einiger Initialisierung um benutzbar zu sein und nach Konstruktion sollte ein Objekt direkt in einem gültigen Zustand sein.
-Ich habe keine Ahnung, was dein drauflegen da machen soll. Es sieht irgendwie so aus, als wolltest du eine verkettete Liste machen, aber die ganzen Bezeichner sind sehr verwirrend. Sieht von den Bezeichnern fast schon wie ein vector aus. daher war ich mir nicht sicher, ob das überhaupt eine Liste sein soll oder ein sehr verunglückter vector.
-Speicherlöcher überall