Kufa> Je comprends pas pk ca planterait ton exemple avec sizeof( Base ) ! = sizeof( Extend ) . ..

C´est vrai que la taille est differente, mais si t´ajoutes une classe derivee, ca ne va utiliser que la partie commune a la classe mere. C´est cette partie qui sera ajoutee ds le tableau. On perd la partie propre a la classe derivee certes, mais si on tente de l´utilisee ca devrait etre signale a la compil.

Je suis d´accord qu´il vaut mieux utiliser des pointeurs, mais ca oblige le programmeur a gerer soit-meme la liberation de la memoire. Avec une classe comme ca, ce n´est plus la peine.
Comme la tendance a l´heure actuelle c´est de liberer le programmeur de la gestion de memoire, ca a qd meme son utilite.
Personnellement, je suis pas partisan. Mais dans plusieurs annees p-e que plus personne n´apprendra ce qu´est un pointeur.
J´aurais eu une classe comme ca a faire, je l´aurais faire avec des pointeurs.

/ *s´aperçoit du niveau du post, se tire discrètement sur la point des pieds...*/

--log

1. include < stdio.h>
2. include < typeinfo>

class Base
{
public:

int m_iValue;

Base() : m_iValue( 0 ) {};
Base( int value ) : m_iValue( value ) {}
virtual float getValue( void ) const { return ( float) m_iValue; }

};

class Extended : public Base
{
public:
float m_fValue;

Extended() : Base( 0 ) , m_fValue( 0.0f ) { }
Extended( float value ) : Base( ( int) value ) , m_fValue( value ) { }
virtual float getValue( void ) const { return m_fValue; }

};

class Test
{
public:

Base m_base;

Test( const Base & ) : m_base( base ) {}

};

int main( int, char ** )
{
Base a( 5 ) ;
Extended b( 6.5f ) ;
Test c( a ) ;
Test d( b ) ;

printf( " %d %d\n", sizeof( Base ) , sizeof( Extended ) ) ;

printf( " %f\n", a.getValue() ) ;
printf( " %f\n", b.getValue() ) ;

printf( " %f\n", c.m_base.getValue() ) ;
printf( " %f\n", d.m_base.getValue() ) ;

printf( " %s -- %s\n", typeid( a ) .name(), typeid( b ) .name() ) ;
printf( " %s -- %s\n", typeid( c.m_base ) .name(), typeid( d.m_base ) .name() ) ;

Extended *ext = dynamic_cast<Extended*>(&.m_base);
if( ext )
printf( " %f\n", ext->getValue() ) ;
else
printf( " Cannot convert..\n" ) ;
return 0;
}
Pas de warning, mais on a clairement pas la bonne valeur..

Je vois pas ou est le pb...
L´affichage donne
5
6.5
5
6

ensuite
Base - ext
Base - Base

et apres ca veut pas convertir

Si tu pouvais dire ce que tu attendais pcq pour moi ca parait normal.

Nan je dis que c bel est bien une limitation d´avoir un contenaire comme ca. Le coder qui utiliserai ca espererai pouvoir contenir toutes les infos de son objet, donc avoir printf( " %f\n", d.m_base.getValue() ) ; qui renvoie 6.5..

Oui c est normal, mais on pert l info de l objet, ce qui est donc tres mauvais..
Ensuite on a de la chance que ca soit bien code, c pas dit qu avec un memcpy ca fonctionne pareil..

Ok j´ai compris ce que tu voulais dire. Mais c´est pas tres dur a voir pcq qd le codeur veut utiliser le containaire il utilise containaire<base>. Donc il doit bien s´attendre a en perdre une partie.
S´il veut acceder aux parties specifiques a la classe derivee, c´est pas la faute au containaire, mais au programmeur qui devrait revoir ses notions d´heritage.
Et avec de la chance, meme s´il fait ca, le compilateur va le jeter pcq il essaira d´utiliser une fonction specifique a la classe derivee.

Oui tout ce que je veux dire c est que ca se passerai bien si il utilisai contenaire<base*>.

Et pis le coder est pas oblige d utiliser des fonctions qui n existent que dans extented pour que ca plante, une fonction virtuelle passera au compilo, mais renverra le mauvais resultat, cf mon exemple..

Ce que je veux dire, c est que c pas propre

Ben c´est l´utilisateur qui code pas propre s´il fait comme dans ton exemple. Je ne pense pas que ca soit la faute a celui qui a fait le contenaire.

Qd je parlais des fonctions specifiques a la classe fille, c´etait pour dire que ca lui montrait qu´il se trompait vu que ca compilait pas, dc ca mene pas forcement a un bug dur a trouver.

Je ne pense pas que ca arrive souvent ce genre d´erreurs qd meme.

D´ailleurs avec des pointeurs, on peut aussi arriver a des bugs.
void f()
{
base B;
contenaire.add(&);
}

Si j´etais de mauvaise fois, je dirais que c´est pas propre ; )

C´est vrai que c´est mieux de stocker des pointeurs ( taille...etc) mais je pense pas que c´est pour faire + propre.

Si c la faute du container, c bcp plus imprudent a mon gout..

Je suis d accord, de toute facon c a l utilisateur de faire gaffe..

Mais, pour moi, si je passes un objet a une fonction ( et non un pointeur), je ne m attends pas a ce que la structure soit modifiee, que mon objet puisse etre utilise d une mauvaise maniere.. Par contre les pbs d alloc, c TJS a l utilisateur de faire gaffe..

J´ai trouvé ( quel idiot ) c´est :
memory = new tableType[nbElements+1];

T´as trouvé ou t´as lu ce que j´avais ecris ( le premier me vexerai) ? ???

( sinon ca sers a rien de repondre )