#include "stdafx.h"
#include <iostream>
#include <string>

using namespace System;
using namespace std;

#ifndef _STACK_H
#define _STACK_H

template <class T> 
class stackNode 
	{

public:

	T data;

    };

template <class T> 
class Stack 
	{

public:
	//Konstruktor,setzt counter auf 0
	Stack(){ counter = 0; }; // Konstruktor (realisiert create() )
	~Stack();				// Destruktor

  bool push(const T&);	//legt element auf stack ab, gibt wahr wenn erfolgreich
  void  pop();				//löscht das oberste element
  T& top() const;			//gibt oberstes element zurück
  bool isEmpty() const;			//testet ob stack leer ist
  int size() const;	//liefert aktuelle anzahl der elemente auf dem stack

private:
  stackNode<T> *topp;			// Zeiger auf Kopf des Stacks
  int counter;				// Anzahl Elemente im Stack

     };

template <class T> bool Stack<T>::push(const T& s)
	{
	if(counter == data)
		return false;
	data[counter++] = s;
	return true;
	}
/*
template <class T> bool Stack<T>::isEmpty()const
	{
	return(counter == 0);
	}
template <class T> int Stack::size() const
	{
	return counter;
	}
template <class T> Stack::top()const
	{
	return *topp;
	}

*/

#endif

int main()
{
//Test mit double werten
double index;
//double Stack definiert
Stack<double> doubleStack;
//Stack füllen mit 5 elementen
for(index=1;index <= 5;index++)
	{

	if(doubleStack.push(index))
	cout << index << " " << "Auf Stack abgelegt" <<endl;
	else 
		{
		cout << "Konnte nicht abgelegt werden" <<endl;
		break;
		}
	}
//Test mit strings

}

Noch zur Erklärung die Templateklasse stackNode soll eine hifsklasse sein zur Speicherung der in dem Stack zu verwaltenden Daten.
gruß Steve

#include <iostream>
#include <string>

#ifndef _STACK_H
#define _STACK_H

template <class T>
class stackNode
{
    public:
        T data;
};
stackNode *anchor;

template <class T>
class Stack
{
    public:
    //Konstruktor,setzt counter auf 0
        Stack(){ counter = 0; }; // Konstruktor (realisiert create() )
        ~Stack();                // Destruktor

        bool push(const T&);    //legt element auf stack ab, gibt wahr wenn erfolgreich
        void  pop();                //löscht das oberste element
        T& top() const;            //gibt oberstes element zurück
        bool isEmpty() const;            //testet ob stack leer ist
        int size() const;    //liefert aktuelle anzahl der elemente auf dem stack

    private:
        stackNode<T> *topp;            // Zeiger auf Kopf des Stacks
        int counter;                // Anzahl Elemente im Stack
};

template <class T> 
bool Stack<T>::push(const T& s)
{
    if(counter == data)
        return false;
    data[counter++] = s;
    return true;
}
/*
template <class T> 
bool Stack<T>::isEmpty()const
{
    return(counter == 0);
}
template <class T> 
int Stack::size() const
{
    return counter;
}
template <class T> 
T Stack::top()const
{
    return *topp;
}

*/

#endif

Jetzt ist er besser
Dann rate ich dir das hier gut und aufmerksam durchzulesen
http://www.willemer.de/informatik/cpp/dynamic.htm

Aber kommen wir nun zu deinem Code.

template <class T> 
bool Stack<T>::push(const T& s)
{
    if(counter == data)
        return false;
    data[counter++] = s;
    return true;
}

Wie soll deine Stack-Methode mit der Variable aus stackNode arbeiten, wenn diese garnicht bekannt gemacht wurde? Außerdem ist data kein Array, also kannst du es auch nicht zu benutzen, es sei denn du würdest ein string übergeben, aber was ist mit einem int?

http://www.cplusplus.com/reference/stl/vector/push_back/
push gibt void zurrück im Normalfall. Du gibst true zurück falls alles richtig ist, gut kann man machen, muss aber nicht unbedingt sein.
So richtig viel Sinn ergibt dein push nicht.
Ich empfehle dir folgende Methode

template <typename T>
bool Stack<T>::push(const T& to_pushing_data) //aussagekräftige Variablennamen, nicht unbedingt so, aber besser als "s"
{
    stackNode *node = new stackNode;
    node->data = to_pushing_data;
    node->next = topp;
    topp = node;
}

Also sieht dein Code im Ganzen so aus:

#ifndef _STACK_H
#define _STACK_H

#include <iostream>
#include <string>

template <class T>
class Stack
{
    public:
    //Konstruktor,setzt counter auf 0
        Stack() : counter(0), topp(0) {}; // Konstruktor (realisiert create() )
        ~Stack();                // Destruktor

        void push(const T&);    //legt element auf stack ab, gibt wahr wenn erfolgreich
        void  pop();                //löscht das oberste element
        T& top() const;            //gibt oberstes element zurück
        bool isEmpty() const;            //testet ob stack leer ist
        int size() const;    //liefert aktuelle anzahl der elemente auf dem stack

    private:
        class stackNode
        {
            public:
                T data;
                stackNode *next_element;
        };
        stackNode *topp;            // Zeiger auf Kopf des Stacks
        int counter;                // Anzahl Elemente im Stack
};

template <class T>
void Stack<T>::push(const T& to_pushing_data)
{
    stackNode *node = new stackNode;
    node->data = to_pushing_data;
    node->next_element = topp;
    topp = node;
    ++counter;
}
/*
template <class T>
bool Stack<T>::isEmpty()const
{
    return(counter == 0);
}
template <class T>
int Stack::size() const
{
    return counter;
}
template <class T>
T Stack::top()const
{
    return *topp;
}

*/

#endif

using namespace std NIEMALS in einer Header Datei verwenden, vorallem, wenn du es nicht brauchst und was soll das mit dem using namespace System? Das kennt mein Code Blocks nicht mal. Genauso wenig brauchst du stdafx.

Stack() { counter = 0; }

Dafür kannst du die Initialisierungsliste nehmen.
Wie du gesehen hast, habe ich die Node Klasse in die Stack Klasse gemacht.

Und bei Windows braucht man die using namespace system und die stdafx....

Nein.
Die stdafx-Dateien sind MS-spezifisch (precompiled Header). Das using namspace hat schon gar nichts mit dem Betriebssystem zu tun.

...

wenn man keine ahnung hat...

stdafx kannst du in projekt-eigenschaften deaktivieren (oder klickst am anfang gleich auf "empty project"/"leeres projekt") und using namespace system hab ich noch nie (in C++) gesehen...

zu der "seltenheit", dass leute, die keine einfachen gui-programme bedienen können, linux bevorzugen, sag ich jetzt mal nichts...

bb

Und bei Windows braucht man die using namespace system und die stdafx....

Brauch man das ? :p
Also ich hab auf meinem PC Windows seit ich auf der Tastatur rumhämmere und ich hab bisher noch nie stdafx oder using namespace System gebraucht. stdafx ist auch soweit ich weiss eigentlich C und du programmierst in C++.

stdafx ist auch soweit ich weiss eigentlich C und du programmierst in C++.

nein?!
bevor ihr so was schreibt, könntet ihr ja wenigsten mal nachlesen, wenn ihr euch nich sicher seid...
stdafx ist der precompilierte header - und unabhängig davon, ob nun gerade C oder C++...

bb

Egal.
Auf jeden Fall wirft der compiler mir eine Fehlermeldung
Er sagt mir
"1>.\dua_u6.2.cpp(49) : error C2955: "stackNode": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich."

und zwar an dieser stelle:

private:
  stackNode *topp;		// Zeiger auf Kopf des Stacks
  int counter;			// Anzahl Elemente im Stack

gruß steve

template <typename T>
class stackNode
{
    ...
};

Wenn ja, dann mach das template weg. Immerhin brauch deine Node Klasse kein Template mehr, da sie jetzt in der Stack Klasse ist, wodurch ein Template bereits existiert.

template <class T> int Stack::size() const
	{
	return counter;
	}

Kommte die Fehlermeldung:
1>.\dua_u6.2.cpp(49) : error C2955: "stackNode": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich."

Bitte ein letztes mal heut abend um hilfe

template <typename T>
int Stack<T>::size()
{
    return counter;
}

Edit:
Du musst dir aber auch mal gut die Fehlermeldungen durchlesen.
Der Error sagt dir was mit einer template Argumentliste. Diese Argumentliste ist das was zwischen den <> steht. Das macht dir klar, dass da was fehlt.

// dua_u6.2.cpp: Hauptprojektdatei.

#include <iostream>
#include <string>

using namespace std;

#ifndef _STACK_H
#define _STACK_H

template <class T> 
class Stack 
	{

public:
	//Konstruktor,setzt counter auf 0
	Stack(): counter(0), topp(0){}		// Konstruktor (realisiert create() )
	~Stack(){}							// Destruktor

  bool push(const T&);					//legt element auf stack ab, gibt wahr wenn erfolgreich
  void  pop();							//löscht das oberste element
  T& top() const;						//gibt oberstes element zurück
  bool isEmpty() const;					//testet ob stack leer ist
  int size() const;						//liefert aktuelle anzahl der elemente auf dem stack

private:								//hier wurde die klasse stackNode mit in die klasse Stack eingefügt, der Übersicht halber, die Funktionen bleiben erhalten
	class stackNode
		{
		public:
			T data;
			stackNode *next_element;
		};
	stackNode *topp;						// Zeiger auf Kopf des Stacks
	int counter;							// Anzahl Elemente im Stack

     };

//pusht element auf stack und gibt war wenn erfolgreich
template <class T> bool Stack<T>::push(const T& to_pushing_data)
	{
	stackNode *node = new stackNode;
	node->data = to_pushing_data;
	node->next_element = topp;
	topp = node;
	++counter;
	return true;
	}

//prüft ob Stack leer ist(0 Stack ist nicht leer und 1 Stack ist leer)
template <class T> bool Stack<T>::isEmpty()const
	{

	if(counter == 0)
		 return true;
	else
		return false;
	}

//gibt die größe des Stackes an
template <class T> int Stack<T>::size()const
	{
	return counter;
	}

//löscht das oberste element
template <class T> void Stack<T>::pop()
	{
	topp = topp->next_element;
	counter--;
	}

template <class T> T& Stack<T>::top()const        !!!!!!!!!!!!!!!!!!!!!!
	{                                        hier merkert der compiler
	                                         !!!!!!!!!!!!!!!!!!!!!!!!!!
	return *topp;
	}

#endif

int main()
{
//Test mit double und string 

//double Stack und string Stack definiert

Stack<double> doubleStack;
Stack<string> stringStack;

//Stack fuellen mit 5 double elementen und 1 string element

//DOUBLE
cout << "DOUBLE" << endl<<endl;
for(double index = 1.101023 ; index <=4 ; index++)
	{
	if(doubleStack.push(index))
	cout << index << " " << "Double-Wert auf Stack abgelegt" <<endl;
	else 
		cout << "Konnte nicht abgelegt werden" <<endl;
	}

cout << "Oberstes Element:  " << doubleStack.top() << endl;
cout << endl<<endl<<endl;

//STRING
cout << "STRING" <<endl<<endl;
string text = "Hallo";

	if(stringStack.push(text))
	cout << "String" << "'" << text <<"'" << "auf Stack abgelegt"<<endl;
	else 
	cout << "Konnte nicht abgelegt werden" <<endl;

cout << "Oberstes Element:  "   << stringStack.top() <<endl;

}

Gruß steve

So aber nun zu deinem Problem.

template <class T> 
T& Stack<T>::top()const
{
    return *topp;
}

Denk mal nach, was genau machst du hier ? Du gibst das GANZE Objekt an die Main zurück. Was bringt dir das? Du kannst das Objekt nicht an cout übergeben. Cout erwartet einen Wert, den es ausgeben kann. Jedoch dein Objekt enthält eine ganze Klasse. Du kannst nicht von cout erwarten eine Klasse auf die Konsole darzustellen. Wie soll es das auch tun ? Was du auf die Konsole schreiben willst, ist den Wert selbst. Da topp ein Objekt von stackNode enthält, kannst du auf stackNode->data zugreifen. Denn in der Variable data, die in stackNode beinhaltet ist, ist den Wert den wir brauchen.

template <class T> 
T& Stack<T>::top()const
{
    return topp->data;
}

Edit:
Glaub mir, solltest du so einen Codestil deinem Chef vorzeigen, lacht er dich aus und gibt dir den neuen Job als Putze.

Denk dran noch einen Destruktor zu bauen. Du hast ihn zwar in der Klasse, jedoch macht er nichts. Du musst durch die Liste und jedes Objekt löschen.

Edit2:
Ich hab grad noch bemerkt, dass deine Pop Methode fast richtig ist, aber etwas entscheidenes fehlt.
Durch pop, gehst du zwar auf das vorherige Element, löschst aber nicht das alte.

template <class T>
void Stack<T>::pop()
{
    stackNode* old_element = topp;
    topp = topp->next_element;
    delete old_element;
    --counter;
}

Und hier noch der Destruktor

template <class T>
Stack<T>::~Stack()
{
    while(topp)
    {
        stackNode* old_element = topp;
        topp = topp->next_element;
        delete old_element;
    }
}

Fast wie die Pop Methode, nur das nunmal alles gelöscht wird
Solltest du noch ne Frage haben, ich bin noch ne weile online

Mit Freundlichem Gruß
Steve

while (!empty())
 pop();

wenn du den code mal vergleichst wirst du nämlich sehen, dass du so das pop und das empty noch mal abgetippt hast - und man versucht ja immer so wenig code wie möglich zu duplizieren (idR schafft man es, ohne Code zu duplizieren ^^)

bb