Est ce que l'on peut apeller automatiquement une méthode définie pour chaque classe définie ?

class Maclasse
{
   public :
   void MaMethode();
};

Maclasse ClasseUn;
Maclasse ClasseDeux;

// Et faire quelque chose a la place de
ClasseUn->MaMethode();
ClasseDeux->MaMethode();

// genre toutelesclasses->MaMethode();

Ensuite comment est-il possible de donner une notion parent enfant? Ca voudrait dire de mettre une classe en tant que variable et d'utiliser les méthodes de cette-dite classe.

tatatavguitextemesouvientplus(texte, parent);//Parent étant la classe ou cette méthode prendra les variables dont a besion l'objet texte;

Quelqu'un peut-il m'expliquer clairement et brèvement la nition de polymorphisme ou bien me donner un lien clairement documenté? Chaque page de google me donne des cours incomplet ou incomprehensibles.

#include <stdio.h>
#include <vector>

class RootClass
{
    public:
    RootClass()
    {
        m_instances.push_back(dynamic_cast<RootClass *>(this));
    }

    virtual ~RootClass()
    {
        std::vector<RootClass *>::iterator it=RootClass::m_instances.begin();
        RootClass *this_obj=dynamic_cast<RootClass *>(this);

        while(it!=RootClass::m_instances.end())
        {
            if((*it)==this_obj)
            {
                RootClass::m_instances.erase(it);
                break;
            }
            it++;
        }
    }

    static void CallAllMyMethod()
    {
        std::vector<RootClass *>::iterator it=RootClass::m_instances.begin();

        while(it!=RootClass::m_instances.end())
        {
            (*it)->MyMethod();
            it++;
        }
    }

    virtual void MyMethod() = 0;

    protected:
    static std::vector<RootClass *> m_instances;
};

std::vector<RootClass *> RootClass::m_instances=std::vector<RootClass *>();

/*
 *
 *
 *
 */
class Test1 : public RootClass
{
    public:
    virtual void MyMethod(){printf("Test1::MyMethod\n");}
};

class Test2 : public RootClass
{
    public:
    virtual void MyMethod(){printf("Test2::MyMethod\n");}
};

class Test3 : public RootClass
{
    public:
    virtual void MyMethod(){printf("Test3::MyMethod\n");}
};

class Test4 : public Test1
{
    public:
    virtual void MyMethod(){printf("Test4::MyMethod\n");}
};

class Test5 : public Test4, public Test2
{
    public:
    virtual void MyMethod(){printf("Test5::MyMethod\n");}
};

int main(int argc,char **argv)
{
    Test1 t;
    Test2 t2;
    Test3 t3;
    Test4 t4;
    Test5 t5;

    printf("===\n");
    RootClass::CallAllMyMethod();

    {
        Test1 tbis;

        printf("===\n");
        RootClass::CallAllMyMethod();
    }

    printf("===\n");
    RootClass::CallAllMyMethod();

    getchar();

    return 0;
}

//attention ce code ne se compilera pas
CGuiScreen fenetre(rouge,vert,bleu,longueur,largeur,x,y);
//Mettons que il y aie des attributs x et y qui prenent les valeurs des parametre x et y du constructeur je voudrais via le constructeur du texte, qu'il puisse prendre les valeurs de fenetre.x et de fenetre.y en mettant simplement quelque chose comme ceci
CGuiTexte texte(fenetre,texte,police,rouge,vert,bleu,xrelatif,yrelatif);
//fenetre etant parent, le constructeur va automatiquement chercher les valeurs des attributs de fenetre et pas d'une autre classe

J'ai un petit problème de mémoire, plus mes fonction de redraw de mes classes sont apellées plus ca rame Quelqu'un a une idée?