problem mit klassen

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.