Diese Seite ist unverschlüsselt! Um sicherzustellen, das Ihr Passwort nicht ausgelesen werden kann, sollten Sie auf die verschlüsselte Seite wechseln!

    Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Vector mit Objekten derselben Basisklasse
Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] > 2 <
010
30.11.2006, 11:01 Uhr
J-jayz-Z
Perl Crack ala Carte
(Operator)


danke
--
perl -Mstrict -Mwarnings -e 'package blub; sub new { bless {} } sub bar {my $self=shift; $self->{bla}="66756e2d736f66742e6465"; return $self->{bla};} my $foo=blub->new();print "Hallo ";print pack("H*",$foo->bar()); print "\n"'
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
011
30.11.2006, 11:37 Uhr
virtual
Sexiest Bit alive
(Operator)



Zitat von stephanw:

Warum das denn ? Wenn Base eine Basisklasse sein soll, von der abgeleitet werden soll/darf, dann sollte der Destruktor virtuell sein. Dann klappts auch mit dem Löschen.

C++:
class Base {
  virtual ~Base();
};

class Derived: public Base {
};



Ja klar muß man die Basisklassen den dtor virtuell amchen. Aber es bleibt dabei:
Wenn das hier unser v ist:


C++:
std::vector<Base*> v;


Und Du dann die Objekte in v rein tust:

C++:
v.push_back(new Base());
...
v.push_back(new Dereived());
...


Dann musst Du dich selbst um die Freigabe der Elemente kümmern (es sei denn, du verwendest smart pointer). Denn ein Base mag vielleicht einen dtor haben, ein Base* aber nicht.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
Dieser Post wurde am 30.11.2006 um 11:38 Uhr von virtual editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
012
30.11.2006, 12:30 Uhr
stephanw
localhorst


Das stimmt. Ich habe Deine Aussage falsch interpretiert. Natürlich muss man mit Listen von Zeigern auf Objekte vorsichtig sein und das Löschen nicht vergessen. Entweder manuell:

C++:
for (unsigned i=0; i < v.size(); ++i)
{
  delete v[i];
}

oder bequemer mit Smart-Pointern.
Als kleine Ergänzung kann man vielleicht hinzufügen, dass man dafür auch std::auto_ptr nutzen kann und nicht zwingend auf boost oder andere Implementierungen angewiesen ist.

Für Details verlinke ich einfach mal Deinen FAQ-Beitrag: www.fun-soft.de/showtopic.php?threadid=5442
--
Reden ist Schweigen und Silber ist Gold.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
013
30.11.2006, 12:51 Uhr
J-jayz-Z
Perl Crack ala Carte
(Operator)



Zitat von http://cppreference.com/cppmisc/auto_ptr.html :

Warning: It is generally a bad idea to put auto_ptr objects inside C++ STL containers. C++ containers can do funny things with the data inside them, including frequent reallocation (when being copied, for instance). Since calling the destructor of an auto_ptr object will free up the memory associated with that object, any C++ container reallocation will cause any auto_ptr objects to become invalid.

--
perl -Mstrict -Mwarnings -e 'package blub; sub new { bless {} } sub bar {my $self=shift; $self->{bla}="66756e2d736f66742e6465"; return $self->{bla};} my $foo=blub->new();print "Hallo ";print pack("H*",$foo->bar()); print "\n"'
Dieser Post wurde am 30.11.2006 um 12:51 Uhr von J-jayz-Z editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
014
30.11.2006, 13:12 Uhr
stephanw
localhorst


Ok, mein Fehler, danke für den Hinweis.

Wobei das schon gar nicht übersetzen dürfte:

C++:
vector<auto_ptr<int> > v;
v.push_back( auto_ptr<int>( new int(77) ) );

da der Copy-Konstruktor von auto_ptr das Original verändert. Wie dem auch sei:

Kein std::auto_ptr in Standard-Container !
--
Reden ist Schweigen und Silber ist Gold.
Dieser Post wurde am 30.11.2006 um 13:13 Uhr von stephanw editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
015
30.11.2006, 15:24 Uhr
Th



 In std::list müssten auto-pointer aber funktionieren, da Listenelement ja nicht verschoben werden?

Aber generell sind smart_pointer natürlich besser.
Ich benutze ansonsten zum Löschen solcher Container immer meine Template-Funktion 'clear':

C++:
template <typename T>
void clear(T &c)
{
    for(typename T::iterator it = c.begin(); it != c.end(); ++it)
        delete *it;

    c.clear();
}
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
016
04.12.2006, 09:29 Uhr
Soto



 Noch ne Frage hätte ich:

Angenommen, ich hab in einer der Unterklassen, Kn, eine Methode do_something() implementiert, die ich in der Basisklasse B nicht deklariert habe.

Gibt es dann eine Möglichkeit, do_something() über den Zeiger auf Objekte von B aufzurufen?
--
ich versuche zu helfen, sorry wenn ich nen scheiß rede ^^
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
017
04.12.2006, 12:15 Uhr
Th



 Wenn du weißt, daß der Zeiger auf die Unterklasse zeigst, dann kannst du einfach statisch casten.
Aber am besten ist "C* pC = dynamic_cast<C*>(pPtrB)".
Falls pPtrB nicht ein C oder eine davon abgeleitete Klasse ist, dann gibt der cast einen Nullzeiger zurück, d.h. pC = 0. Nun kannst du dann einfach pC->do_something() aufrufen.
RTTI muß dann aber beim Compiler aktiviert sein.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] > 2 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: