Objekte von selbst entwickelten Klassen als Rückgabewert

Hallo,
ich versuche mir grad c++ beizubringen. Da ich schon Java kann ist vieles recht einfach, anderes aber wieder völlig anders und treibt mich daher zur verzweifelung...
Ich habe jetzt konkret folgendes Problem:

Ich habe mir eine Stack-Klasse geschrieben und möchte nun, in einer anderen Klasse, eine Methode schreiben, die eine Datei zeile für zeile einliest und eben auf diesen Stack legt. Dieser soll dann zurückgegeben werden. Das sieht folgendermaßen aus:

#include "Stack.h"

[..]

public:
       Stack dateiEinlesen(string dateiname) {
                  [..]
       }

Der rest ist ja, denke ich, nicht so relevant. Beim kompilieren kommt der Fehler "Stack does not name a type". Muss ich vorher irgendwie den Datentyp Stack definieren oder geht die Rückgabe unter c++ schlichtweg nicht?

Vielen Dank
Fish

Ps: Hätte nebenbei noch eine Frage zu c++ was die Namensgebung angeht. Ich bin von java gewohnt das z.B. Klassennamen groß geschrieben werden sollten (dementsprechend auch die Dateinamen), konstanten komplett groß, etc.

Habe nun aber gesehn das die c++-libraries alle klein geschrieben sind. gibt es für c++ keine formalitäten diesbezüglich oder wenn ja, wie unterscheiden die sich von java?

CStoll

thafish schrieb:

Der rest ist ja, denke ich, nicht so relevant.

Doch, der Inhalt von "Stack.h" könnte relevant werden - eventuell hast du dich einfach verschrieben (Stack, stack und STACK sind drei völlig verschiedene Bezeichner).

gibt es für c++ keine formalitäten diesbezüglich oder wenn ja, wie unterscheiden die sich von java?

Wirkliche Festlegungen dazu kenne ich nicht, da hat fast jeder Programmierer seinen eigenen Stil (ungarische Notation, Großschreibung, Kleinschreibung,...). Die Klassen der Standardbibliothek sind jedenfalls komplett klein geschrieben (und im Namensraum std verpackt).

Na gut, dann hier der Quelltext:

einmal die Klasse Stack.h:

#include <iostream>

using namespace std;

template <class T>
class Stack {
      private:
            T *content;   
            int pointer;
            int size;

      public:
            //Default-Konstruktor: Stack hat maximal 100 Elemente
            Stack () {
                  size=100;
                  pointer=-1;
                  content = new T[size];
            } 

            //Konstruktor, dem die maximale Groesse des Stacks angegeben wird
            Stack (int s) {
                  size = s;
                  pointer = -1;
                  content = new T[size];
            }

            //Element oben auf den Stack legen
            void push (T element) {
                 if(pointer < size-1) {
                      ++pointer;
                      assert(content[pointer] = element);
                 }
                 else {
                      cout<<"ERROR: Maximum Stacksize = "<<size<<" reached!"<<endl;
                 }
            }

            //Oberstes Element vom Stack holen
            T pop () {
                  if(pointer != -1) {
                       --pointer;
                       return content[pointer+1];
                  }
                  else {
                       cout<<"ERROR: Stack empty!"<<endl;
                       return 1;
                  }
            }

            //Gibt zurueck ob der Stack leer ist
            bool empty () {
                 if (pointer == -1) {
                      return true;
                 }
                 else {
                      return false;
                 }
            }

            //Gibt die Anzahl der Elemente im Stack zurueck
            int elementCount () {
                return pointer+1;
            }   

};

und jetzt noch die sog. Klasse Logik, in der bisher nur die Methode dateiEinlesen steht:

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include "Stack.h"

using namespace std;

class Logik {
      public:
              Stack dateiEinlesen() {
                  ifstream input;
                  input.open("datei.txt");
                  string line;
                  Stack<int> stack(10000);
                  getline(input, line);
                  istringstream iss;

                  while(!input.eof()) {
                        //Umwandeln des eingelesenen strings in einen Integer              
                        int lineint;
                        iss.str(line);
                        iss >> lineint;
                        //Integer auf den Stack legen
                        stack.push(lineint);

                        getline(input, line);                  
                 }                   
                 return stack;      
             }
};

Ich hoffe das hilft weiter. Das Stack stack und STACK 3 verschiedene Dinge sind ist mir allerdings klar (linux user ), von daher würde es mich wundern wenn es daran liegt.

mfG
thafish

huch, hab die oberste Zeile in der Stackklasse vergessen, das is #include <assert.h>; daran liegts also auch nich. (ich melde mich jetzt gleich mal an, damit ich meine posts in zukunft editieren kann *g*

__HIRSCH_H__

Der Templateparameter gehört zum Typ mit dazu, die Signatur der Methode muss also so sein:

Stack<int> dateiEinlesen(string dateiname)

Nanyuki

HIRSCH_H schrieb:

Der Templateparameter gehört zum Typ mit dazu, die Signatur der Methode muss also so sein:
Stack<int> dateiEinlesen(string dateiname)

...oder so?

Stack<string> dateiEinlesen(string dateiname)

thafish

Danke, das war schonmal ein guter Hinweis.

Leider bekomme ich jetzt ein:
"redefinition of `class Stack<T>`" und ein
"previous definition of `class Stack<T>"
als Fehlermeldung vom Compiler.

Wird wohl irgendwie an den Includes liegen, da ich den gleichen Fehler auch für eine andere Klasse erhalte, die ich aber im Moment im Programm noch nicht verwende, allerdings steht sie schon als include drinnen...

(btw., den fehler hatte ich vorher schon drinnen, ich dachte allerdings das es daran liegt, das er den rückgabewert "Stack" als neue definition o.ä. ansieht und demnach dann "Stack" doppelt vorhanden ist. wenn ich jetzt drüber nachdenke kommts mir auch komisch vor )

Artchi

Willst du nicht erstmal C++ Basics lernen bevor du z.B. Templates benutzt? (so interessant sie auch sein mögen)

Du hast in deinen Headern bestimmt einen Include-Wächter vergessen? Die gehören nämlich auch in die Kategorie "C++ Basics".

thafish

Danke für den Tipp, das wars.

zu den basics:

Ich hab mir das komplette volkard-c++-tutorial durchgelesen (http://www.volkard.de/vcppkold/inhalt.html) und auch verstanden.

Nur leider war da nie die Rede von include-guards (es sei denn es iss irgendwo ganz kurz erwaehnt und ich habs tatsaechlich ueberlesen...), sodass ich bisher noch nichmal wusste das es sowas gibt.

gruß
thafish