Array Stack push

[ghorst]

drakon schrieb:

Das müsste einen Compile Fehler geben.

warum sollte es einen solchen geben? das ist in c und c++ völlig legal

[drakon]

ghorst schrieb:

drakon schrieb:

Das müsste einen Compile Fehler geben.

warum sollte es einen solchen geben? das ist in c und c++ völlig legal

Wenn es ein semantischer Fehler ist, dann muss das der Compiler entdecken. Vielleicht will er ja ein Array von Zeigern auf chip haben. Im übrigen ruft er ja new auf und übergibt den Zeiger der Klasse, wo er den Zeiger in einem Array speichert. Das kann er so ganz gut machen. (Über das schlechtes Design reden wir hier mal nicht)

[Dravere]

ghorst schrieb:

drakon schrieb:

Das müsste einen Compile Fehler geben.

warum sollte es einen solchen geben? das ist in c und c++ völlig legal

Schau dir den Code nochmals an. In dem Code wird ein Array von Zeigern benötigt. Wenn du nur ein Array von Objekten machst, dann gibt es bei der push Funktion sicher einen Compile-Fehler

@Zeiteisen,
Das was Drakon sagt ist korrekt, aber du solltest auch noch die zwei nachfolgenden for-Schleifen begutachten, die haben genau denselben Fehler. Einfach das <= durch ein < ersetzen.

Grüssli

[Zeiteisen]

drakon schrieb:

ghorst schrieb:

drakon schrieb:

Das müsste einen Compile Fehler geben.

warum sollte es einen solchen geben? das ist in c und c++ völlig legal

Wenn es ein semantischer Fehler ist, dann muss das der Compiler entdecken. Vielleicht will er ja ein Array von Zeigern auf chip haben. Im übrigen ruft er ja new auf und übergibt den Zeiger der Klasse, wo er den Zeiger in einem Array speichert. Das kann er so ganz gut machen. (Über das schlechtes Design reden wir hier mal nicht)

Erzähl mir bitte was über das schlechte Design.
Hab das mit den for Schleifen korrigiert. Das eigentliche Problem ist leider nicht gelöst.

[drakon]

Du hast immernoch das gleiche Problem, aber diesmal anderst.

for (int i=0; i<=size; i++)
        {
            counter[feld[i]->zeigdich()]++;
        }

Hier wird bei chip_2 2 zurückgegeben. Bei aller lieber zur 2, geht das bei einem Array der Grösse 2 einfach nicht.

Zum Design:
1. Du übergibst den Zeiger, den du per new anforderst an eine Klasse, die den Verwalten soll. Wer soll das den jetzt aufräumen? Deiner Meinung nach ja der User der Klasse, was ihm aber so ohne weiteres nicht (so einfach) möglich ist.

2. Du scheinst dich in deinem eigenen Code ja nicht sehr auszukennen und daher kann das gar kein gutes Design sein,wenn der Programmierer selbst da nicht durchblickt.

3. Ich nehme mal an, dass du da ein RTTI System simulieren willst. Das geht aber besser (wenn überhaupt nötig) per dynamic_cast<>.

[Simon2]

BTW: Warum selbst einen Stack schreiben, wenn's den schon im Standard gibt ?

Gruß,

Simon2.

[Zeiteisen]

drakon schrieb:

Zum Design:
[..]
2. Du scheinst dich in deinem eigenen Code ja nicht sehr auszukennen und daher kann das gar kein gutes Design sein,wenn der Programmierer selbst da nicht durchblickt.

Also hat das hier jeder Fragender

Nunja das ist eine Klausuraufgabe mit einigen Lösungsvoraussetzungen.
Und es stürzt immernoch ab... Dennoch danke für die schnellen Antworten.

[OhneName]

Dem Standard-Stack lässt sich halt nicht so einfach eine Methode "zeigdich" hinzufügen, da man ja nicht über die Elemente im Stack iterieren kann. Und bevor man sich eine Wrapperklasse um den Standard-Stack schreibt, die die Elemente beim Einfügen zählt, kann man sich auch gleich nen eigenen Stack schreiben:

#include <iostream>
#include <vector>
#include <map>

struct foo
{
    virtual int bar() const = 0;
};

struct foo_a : foo
{
    int bar() const { return 0; }
};

struct foo_b : foo
{
    int bar() const { return 1; }
};

struct foo_c : foo
{
    int bar() const { return 2; }
};

class foo_stack
{
    public:
        bool empty() const
        {
            return foos.empty();
        }

        void push(foo* f)
        {
            foos.push_back(f);
        }

        foo* top()
        {
            return foos.back();
        }

        void pop()
        {
            foos.pop_back();
        }

        size_t size() const
        {
            return foos.size();
        }

        friend std::ostream& operator<< (std::ostream& os, const foo_stack& s)
        {
            std::map<int, int> count;
            for(std::vector<foo*>::const_iterator iter = s.foos.begin(), end = s.foos.end(); iter != end; ++iter)
            {
                ++count[(*iter)->bar()];
            }
            for(std::map<int, int>::const_iterator iter = count.begin(), end = count.end(); iter != end; ++iter)
            {
                os << "Vom Typ " << iter->first << " vorhanden: " << iter->second << std::endl;
            }
            return os;
        }

    private:
        std::vector<foo*> foos;
};

int main()
{
    foo_stack s;
    s.push(new foo_a());
    s.push(new foo_b());
    s.push(new foo_a());
    s.push(new foo_c());

    std::cout << s;

    while(!s.empty())
    {
        foo* f = s.top();
        s.pop();
        delete f;
    }
}

[drakon]

Zeiteisen schrieb:

drakon schrieb:

Zum Design:
[..]
2. Du scheinst dich in deinem eigenen Code ja nicht sehr auszukennen und daher kann das gar kein gutes Design sein,wenn der Programmierer selbst da nicht durchblickt.

Also hat das hier jeder Fragender

Nunja das ist eine Klausuraufgabe mit einigen Lösungsvoraussetzungen.
Und es stürzt immernoch ab... Dennoch danke für die schnellen Antworten.

Das ist auch nicht unsere Aufgabe deinen Code zu verstehen und wir haben ihn ja nicht geschrieben.

Na, wenns ne Aufgabe ist, dann solltest du dich mal ransetzen und mal ein wenig überlgen und den Debugger benutzen. Ich hätte kein Problem das zu lösen und die Fehler zu finden, aber dazu habe ich keine Lust, wenn du selber keine Initiative zeigst.

[Zeiteisen]

Für die es interessiert:
Die Fehler waren alle in der zeigdich Methode und zwar:

korrigierter zeigdich

void zeigdich()
	{
		int counter[3];
		for (int i=0; i<3; i++)
		{
			counter[i] = 0;
		}

		for (int i=0; i<top; i++)
		{
			counter[feld[i]->zeigdich()]++;
		}

		for (int i=0; i<3; i++)
		{
			cout << "Von Typ " << i << " vorhanden: " << counter[i] << endl;
		}
	}