Was hast du selbst schon gemacht? Wo hängst du? Oder willst du einfach nur eine Komplettlösung, weil du zu faul bist?

i hab grad nachgschaut, leider ham wir damals keine übung nr. 10 ghabt.
du hast das listenbeispiel aus der vorwoche funktionsfähig implementiert? wenn ja, dann sollte ja diese kleine erweiterung kein problem sein. bzw stell konkrete fragen, wo du probleme hast. kein mensch wird sich 5 seiten source anschauen und sich da reindenken!
bzw finde ich, dass bsp 7 (zug bsp) auch nicht so schwer ist.

1. Sourcecode in DOC-Dateien hergeben ist böse. Abgesehen, dass das fast schon einen negativen Geek-Faktor hat, muss man es erst mal rauskopieren, um es compilieren zu können.

2. Ich zitiere aus dem Source: //"eigentlich ist ein struct eine Klasse mit nur oeffentlichen members"
Stimmt nicht. Nur der _Defaultzugriff_ ist public. Du kannst sehr wohl z.b. auch "private: int i;" reinschreiben.

3. ad 10.2: Ausgabe ist trivial. Eingabe: Einen Miniparser schreiben: Auf [ matchen. Dann Zahl als String einlesen, bis ',' erreicht wird. Zahl in Integer umwandeln und an die Liste anhängen. Weiter, bis ] erreicht ist. Und natürlich dazwischen immer auf ungültige Zeichen checken.

ich bin mir jetzt nicht sicher ob es in c++ auch so ist aber eine struct kann zudem auch keinen default konstruktor sondern nur parametrisierte konstruktoren haben

Zitat von Vevusio

ich bin mir jetzt nicht sicher ob es in c++ auch so ist aber eine struct kann zudem auch keinen default konstruktor sondern nur parametrisierte konstruktoren haben

Doch, eine struct und eine class sind in C++ exakt dasselbe, bis auf den Unterschied mit dem Defaultzugriff.

Das Beispiel

struct Test {
 Test() { }
};

compiliert anstandslos (auch wenn das kein formaler Beweis ist).

hm... ich hab mir das grad so überlegt, man sollte ja keine pointer verwenden sondern referenzen, aber lässt sich das überhaupt mit referenzen lösen?

node muss ja ein next haben, wenn next vom typ Node& ist dann muss ich im default konstruktor von Node next einen wert geben

referenzen können in c++ nicht NULL sein, also muss ich ein new Node() darauf erstellen, das new Node muss wieder nen next haben etc etc, endlos rekursiver konstruktor

hab ich da nen denkfehler drin oder lässt sich ne linked list in c++ halt nur über pointer realisieren

hm ja gut ich werd dir irgend eine von denen da lösen heute nacht

muss aber erstmal pc spielen danach mach ich schnell eine

Zitat von moKe

Ich komme einfach nicht weiter, hat jemand eine fertige Aufgabe für mich bitte bitte bitte ich Brauchs dringend !!!!! :wein: :wein: :wein:

Ich hab' ein Zeugnis, soll ich dir's vielleicht durchfaxen, dann hast es sofort! Oder soll ich's lieber gleich auf die Uni tragen zum Einreichen? Naja, schreib' einfach, wie's dir lieber ist!

Schreiben Sie eine Klasse (mit Konstruktor, Destruktor, Kopierkonstruktor, Zuweisungsoperator), die zu jedem Zeitpunkt „weiß“, wieviele Instanzen dieser Klasse gerade existieren. Diese Information soll über eine Methode [FONT=Courier new] anzahlInstanzen() [/FONT] dieser Klasse (Rückgabetyp [FONT=Courier new] unsigned int[/FONT]) abfragbar sein.
  Schreiben Sie ein Hauptprogramm zum gründlichen Testen der Klasse und lösen Sie folgende Teilaufgaben:[LIST]
[*] Implementierung der Klasse wie oben beschrieben
[*] Überladen Sie den Operator +, so daß Additionen zwischen Klassenobjekten und die Addition eines Integers (von links und von rechts) zu einem Klassenobjekt möglich sind. D.h. folgendes Hauptprogramm soll fehlerlos kompilieren (Das Ergebnis des Operators + soll wieder ein Objekt der Klasse sein. Der Wert des Resultats ist aber unerheblich). void main() 
{
  Klasse x,y;
  int i;

  x+y,(i=Klasse::anzahlInstanzen());
  cout<<i<<",";


  x+y;
  i=Klasse::anzahlInstanzen();
  cout<<i<<endl;
}
[*] Lassen Sie das gegebene Programmstück laufen. Vergleichen Sie die Ausgaben der Version der Klasse mit Kopierkonstruktor und einer Version ohne Kopierkonstruktor. Interpretieren Sie die Ergebnisse.[/LIST]

Lösung:

//IntWrapper.h
#ifndef INTWRAPPER_H
#define INTWRAPPER_H


#include "IntWrapperCount.h"


namespace IntWrapper
{
    class IntWrapper
    {
        //Attributes
    private:
        int content;
        static IntWrapperCount intWrapperCount;
        //Constructors & Destructors
    public:
        IntWrapper():
            content(0) { intWrapperCount.IncreaseWrapperCount(); }
        IntWrapper(const IntWrapper &aIntWrapper):
            content(aIntWrapper.GetContent()) { intWrapperCount.IncreaseWrapperCount(); }
        IntWrapper(int aInt):
            content(aInt) { intWrapperCount.IncreaseWrapperCount(); }
            ~IntWrapper() { intWrapperCount.DecreaseWrapperCount(); }
        //Methods
        inline int GetContent() const { return content; }
        inline void SetContent(int aContent) { content = aContent; }
        static inline unsigned int GetIntWrapperCount() { return intWrapperCount.GetWrapperCount(); }
        //Operators
        inline IntWrapper& operator=(const IntWrapper &aIntWrapper)
        {
            content = aIntWrapper.GetContent(); 
            return *this;
        }
        inline IntWrapper& operator=(const int &aInteger)
        {
            content = aInteger;
            return *this;
        }
        inline IntWrapper& operator+=(const IntWrapper &aIntWrapper)
        {
            content += aIntWrapper.GetContent();
            return *this;
        }
        inline IntWrapper& operator+=(const int &aInteger)
        {
            content += aInteger;
            return *this;
        }
        const IntWrapper operator+(const IntWrapper &aIntWrapper) const
        {
            return IntWrapper(*this) += aIntWrapper;
        }
        const IntWrapper operator+(const int &aInteger) const
        {
            return IntWrapper(*this) += aInteger;
        }
        //Implementations
    };
}


#endif

//IntWrapperCount.h
#ifndef INTWRAPPERCOUNT_H
#define INTWRAPPERCOUNT_H


namespace IntWrapper
{
    class IntWrapperCount
    {
        //Attributes
    private:
        unsigned int wrapperCount;
        //Constructors & Destructors
    public:
        IntWrapperCount():
            wrapperCount(0) {}
        //Methods
    public:
        inline unsigned int GetWrapperCount() const { return wrapperCount; }
        inline void IncreaseWrapperCount() { wrapperCount++; }
        inline void DecreaseWrapperCount() { if(wrapperCount > 0) wrapperCount--; }
        //Implementations
    };
}


#endif

main, halt die die vorgegeben war

//main.cpp
#include <iostream>
#include "IntWrapper.h"


using namespace std;


IntWrapper::IntWrapperCount IntWrapper::IntWrapper::intWrapperCount;


void main() 
{
    IntWrapper::IntWrapper x,y;
    int i;

    x+y,(i=IntWrapper::IntWrapper::GetIntWrapperCount());
    cout<<i<<",";


    x+y;
    i=IntWrapper::IntWrapper::GetIntWrapperCount();
    cout<<i<<endl;
}

ergebnis mit copy constrkutor 3, 2
interpretation: najaa also dieser , operator... (ist es überhaupt ein operator) bewirkt halt dass x + y ausgeführt wird, dabei wird ein neues IntWrapper objekt erstellt, noch bevor es aber wieder gelöscht wird, wird i initialisiert, dahier ist i zuerst 3

beim zweiten mal wird einfach x+y; in einem schritt ausgeführt, neues objekt wird erstellt und gleich wieder verworden, dann wird i initialisiert, dahier ist i = 2

wenn man den copy construktor wegkommentiert kommt 1, 0 raus, sieht so aus als würde es also einen default copy constructor geben der einfach nichts macht (also auch nicht den count inkrementiert)

ich hätte eigentlich erwartet dass bei der ersten ausgabe eine 2 kommt, nach den beiden durch , getrennten operationen der count 1 ist und nach dem x + y; auf 0 fällt also dass die ausgabe 2, 0 ist

ich weiß ehrlich gesagt nicht wieso es 1, 0 ist.. wäre nett wenn das jemand erklären könnte

ich wollte zuerst eigentlich die linked list machen aber wie gesagt, ich weiß nicht wie das mit referenzen only gehen sollte (und mit pointern hatte ich keine lust, wollt was neues probieren weil ich vorher in c++ noch nie referenzen verwendet habe so richtig) wegen diesem next pointer, also, aus meinem 2t-vorherigen post

Zitat

hm... ich hab mir das grad so überlegt, man sollte ja keine pointer verwenden sondern referenzen, aber lässt sich das überhaupt mit referenzen lösen?

node muss ja ein next haben, wenn next vom typ Node& ist dann muss ich im default konstruktor von Node next einen wert geben

referenzen können in c++ nicht NULL sein, also muss ich ein new Node() darauf erstellen, das new Node muss wieder nen next haben etc etc, endlos rekursiver konstruktor

hab ich da nen denkfehler drin oder lässt sich ne linked list in c++ halt nur über pointer realisieren

wäre auch nett wenn jemand dazu auch was sagen könnte

Zitat von Vevusio

wäre auch nett wenn jemand dazu auch was sagen könnte

Dein kameradschaftlicher Einsatz ist phänomenal. Allerdings hält sich dadurch der Lernwert unseres Kollegen in Grenzen. Außer das massives Sudern erfolgversprechend ist. Denn er hat meines Erachtens ein geringes Mass an Eigenständigkeit und Selber-Nachdenken bewiesen und das ist das Minimum was ein Student und künftiger Absolvent leisten sollte.

my2c
q