problem mit klassen

ich hoffe einer kann helfen oder ich gebe mir die kugel

ich möchte eine GUI selber erstellen. soweit, sogut. nur jetzt habe ich ein darstellungsproblem.
ich realisiere das ganze so.

ich habe eine basisklasse namens "gui_elemente" und erstelle mit hilfe dieser unter anderem eine gui_button und gui_edit klasse

class gui_elemnte
{
public:
virtual void OnShow(); // funktion ist leer
};

class gui_button : public gui_elemnte
{
public:
void OnShow(); // hier wird der button gezeichnet
};

um alles darzustellen habe ich mir einen container geschaffen

map<int, shared_ptr<gui_element> > e_element;

füge elemente hinzu

e_element[0].reset(new gui_button(50,100));
e_element[1].reset(new gui_button(50,200));
e_element[2].reset(new gui_button(50,300));

und möchte es darstellen

map<int, shared_ptr<gui_element> >::iterator it = e_element.begin();
while (it != e_element.end())
{ 
	(*it->second).OnShow();
	it++;
}

so und das darstellen ist das grosse problem.
er will wirklich die OnShow() von gui_element darstellen statt das OnShow() von gui_button

wenn ich jetzt zum beispiel gui_element mit gui_button austausche

map<int, shared_ptr<gui_button> > e_element;

und so darstelle, funktioniert auch alles

map<int, shared_ptr<gui_button> >::iterator it = e_element.begin();
while (it != e_element.end())
{ 
	(*it->second).OnShow();
	it++;
}

geht mein oberer weg so nicht?
ich möchte alle meine gui sachen in einen container ablegen um sie so besser verwalten zu können.
da bleibt nur noch eines .. nach hilfe schreien und aufs beste hoffen

KPC

Versuch statt

(*it->second).OnShow();

mal:

(it->second)->OnShow();

Außerdem frag ich mich warum du eine Map verwendest, hier sieht ein vector wesentlich angebrachter aus, oder irre ich?

ne der zeiger muss schon.
keiner eine idee .. verdammt ich bon am arsch

machs einfach so wie KPC es gesagt hat und fertig!!!!

wenn ich dies tu, dann bekomme ich das:
error C2039: 'OnShow' : Ist kein Element von 'shared_ptr<class gui_element>'

und weiter?

SirLant

Ne der Zeiger muss nicht, da it ja kein Zeiger auf nen Iterator ist, somit kannst
du direkt auf Elemente zugreifen.

Was du vllt. meinst ist *(it->second).OnShow (), wobei du dafür auch it->second->OnShow (); schreiben könntest

schön und gut und wer erklärt das jetzt meinem compiler?
der "second" eintrag ist ein pointer ein shared_ptr<>, also muss ein zeiger auch rein. oder ich irre mich total .. nunja

SirLant

der Iterator selbst ist ja ein Zeiger, den kannst du dereferenzieren und dann auf
das Objekt zugreifen, das zweite Element (second) ist wieder ein Zeiger den dereferenzierst
du wieder und hast dann deine Klassenmember.

Das ganze sieht, dann wie in meinem oberen Posting aus.

das funktioniert
(*it->second).OnShow();
it->second->OnShow();

das nicht
(it->second)->OnShow();
*(it->second)->OnShow();

inwiefern hat das aber überhaupt was mit meinem problem zu tun in welcher schreibweise ich das nun mache?

es bleibt ja immernoch die frage, wie ich nun es hinbekomme das nicht das OnShow() von gui_element, sondern das OnShow() von gui_button und gui_edit angesprochen wird. das womit ich praktisch die map aufgefüllt habe.

SirLant

indem du die Funktion/Methode virtuell machst und sie in den abgeleiteten Klassen überschreibst

ja aber genau das mache ich doch (siehe einleitungsbeitrag)

class gui_elemnte
{
public:
virtual void OnShow(); // funktion ist leer
};

class gui_button : public gui_elemnte
{
public:
void OnShow(); // hier wird der button gezeichnet
};

SirLant

Hatte nur die untere Klasse gesehen.

Funktioniert denn ein einfaches

gui_elemente *p = new gui_button;

p->OnShow;

ja einzeln funktioniert alles.
und wenn ich statt das gui_element im map container gui_button nehme, stellt er diese auch dar. aber das steht auch im schluss meines einleitungsbeitrages

Hast Du mal folgendes ausprobiert?
[cpp]
class gui_elemnte
{
public:
virtual void OnShow() = 0; // funktion ist leer
}; [/cpp]

ich bin auch schon am verzweifeln.

der gui_button an sich geht ja. er stellt alles richtig dar:

map<int, shared_ptr<gui_button> > e_element;
e_element[0].reset(new gui_button(50,100));
e_element[1].reset(new gui_button(50,200));
e_element[2].reset(new gui_button(50,300));
map<int, shared_ptr<gui_button> >::iterator it = e_element.begin();
while (it != e_element.end())
{
    (*it->second).OnShow();
    it++;
}

es geht aber nicht wenn ich in den container gui_element packe, damit ich darin gui_button und andere komponenten ablegen kann, die sich ja bis auf die basis funktion von gui_element, doch recht stark unterscheiden.

es schein so das bei:

map<int, shared_ptr<gui_element> > e_element;
e_element[0].reset(new gui_button(50,100));
e_element[1].reset(new gui_button(50,200));
e_element[2].reset(new gui_button(50,300));
map<int, shared_ptr<gui_element> >::iterator it = e_element.begin();
while (it != e_element.end())
{
    (*it->second).OnShow();
    it++;
}

nur die werte an gui_element übergeben werden und gui_button selber nicht weiter verwendet wird.
ich meine das => e_element[0].reset(new gui_button(50,100));
einfach die 50 und 100 in gui_element x und y einträgt und gui_button als solches nicht weiter existiert.

also kann man nicht wirklich in eine liste einer basisklasse abgeleitete klassen ablegen. so das man sie und ihre eigenen funktionen auch verwenden kann.

rüdiger

ich kann dein Problem absolut nicht nachvollziehen. Vielleicht ist dein Compiler kaputt oder das Problem liegt woanders

#include <iostream>
#include <map>
#include <boost/shared_ptr.hpp>

struct base {
  virtual void show() const { std::cout << "base::show" << std::endl; }
};

class foo : public base {
  int i;
public:
  foo(int j=0) : i(j) { }
  void show() const { std::cout << "foo::show -> " << i << std::endl; }
};

typedef boost::shared_ptr<base> sptr;

int main() {
  std::map<int,sptr> m;
  m.insert(std::pair<int,sptr>(0,sptr(new foo(10))));
  m.insert(std::pair<int,sptr>(1,sptr(new foo)));
  for(std::map<int,sptr>::const_iterator i=m.begin();
      i!=m.end();
      ++i)
    (*i->second).show();
}

probier den Code mal. Gibt bei mir (g++ 3.3) folgendes aus

> g++ -Wall -W -std=c++98 base.cc
> ./a.out 
foo::show -> 10
foo::show -> 0

@kingruedi
getestet und es geht. leicht umgeschrieben auf gui_ und es geht
ok, nochmal meine klassen genau angeschaut und herzinfakt bekommen.

ich bin so dumm das es zum himmel stinkt

ich habe in meiner gui_element klasse
virtual void show();
und in meinen anderen klassen ne erweiterung eingebaut
void show(int index = -1);

dadurch das ich aber die funktionalität noch nicht implentiert habe, habe ich überall nur show() stehen und mir ist es absolut nicht aufgefallen.

nachdem ich in gui_element den funktionsrumpf angepasst habe geht es nun.
oh man! ihr dürft jetzt die steine werfen. ich habe es verdient

vielen dank für eure hilfe. ich suche mir jetzt jetzt ne wand wo ich erstmal paar mal gegen laufen werde.