Discussion :

[IsraGab]

Salut,
je suis en train de lire l'article de wikipedia sur les type system. J'ai vu qu'ils ont noté le c++ comme etant un language statiquement typé.
Il est vrai que le type en c++ est atribué a la compilation, et les casting sont explicites.
Mais il n'en demeure pas moins vrai que l'utilisation des templates rendent la langue un peu dynamique, non?

[oodini]

Je crois que l'instanciation des templates se fait avant la compilation. C'est en quelque sorte une commodité d'édition.

[Flob90]

Bonjour,

De mémoire la classification des langages des des catégories liées au typage est un vrai bazar.

Il me semble aussi que le cractère dynamique/statique du typage est lié au fait que dans un premier cas le type est déterminé à l'execution et dans l'autre à la compilation. Si c'est la définition que tu prends alors le C++ est plus ou moins entre les deux.

En C++ il y a deux types pour chaque entités : le type statique, determiné à la compilation, et le type dynamique, qui représente le type réel d'un objet. L'un caractèrise donc l'entitée à travers laquelle on manipule l'objet, et l'autre l'objet en lui même.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
struct A {};
struct B : A {};
 
//main
B b; //b est une variable dénotant un objet de type B
//le type statique de b est donc B (c'est explicite)
//le type dynamique est aussi B
A* a = &b; //a est un pointeur initialisé avec l'addresse de notre objet de type B
//le type statique de *a est A (c'est explicite, le compilateur le sait par la grammaire du C++)
//le type dynmaique de *a est B, car quand on déréférence le pointeur on manipule l'objet pointé, qui ici est un objet de type B

[skeud]

en ce qui concerne les template, lors de la compilation, le compilo va te genrer ta class pour les différent type de variable que tu va utiliser:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
template <typename T>
clas toto
{
  T var;
};
 
int main()
{
  toto<int> t1;
  toto<char> t2;
  toto<std::string> t3;
}

va générer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class toto
{
 int var;
};
 
class toto
{
 char var;
};
 
class toto
{
 std::string var;
};

Je me souviens qu'il y a une methode avec g++ pour afficher ces fichiers générer temporairement lors de la cimpilation mais j'arrive pas a remettre la main dessus

[IsraGab]

Salut,

Il me semble aussi que le cractère dynamique/statique du typage est lié au fait que dans un premier cas le type est déterminé à l'execution et dans l'autre à la compilation. Si c'est la définition que tu prends alors le C++ est plus ou moins entre les deux.

C'est effectivement la definition que je connais.
Seulement je ne comprend pas (d'apres ton exemple), comment se fait il qu'il soit a la fois dynamique et a la fois statique?

Ce que je sais egalement, c'est que le type dynamique permet une affectation de A (pour reprendre ton exemple), vers une nouvelle structure C (par exemple). Ca marche a la compilation en tout cas. Le c++, me renverra une belle erreur de casting.

[IsraGab]

Le terme de Template est donc une commodité pour le programmeur, si je comprend bien. Mais en ce qui concerne le code, il n'est pas du tout approprié...

[skeud]

L'exemple de la structure est une sorte d'héritage:

L'objet A est de type A
Et l'objet B est de type A spécialiser en B

Lors de la remonter, le B se transforme en A en "perdant" une partie de ses données (tu ne pourra pas acceder aux données de B sans redscendre dans l'héritage)

d'un point de vu statique sa sera un objet de type A mais d'un point de vue dynamique (donc par rapport a la mémoire effective de ton programme) sa sera un objet de type A spécialiser B

[IsraGab]

Merci, j'avais mal lu son exemple.

tu ne pourra pas acceder aux données de B sans redscendre dans l'héritage

Je ne savais pas qu'il etait possible d'acceder aux données de B par l'intermediaire d'un objet de la classe mère.

[IsraGab]

Il n'y a aucun probleme de Dangling Pointer dans cette exemple?

[koala01]

Salut,

Merci, j'avais mal lu son exemple.



Je ne savais pas qu'il etait possible d'acceder aux données de B par l'intermediaire d'un objet de la classe mère.

Ben, c'est ce que fait le dynamic_cast... :
soit la hiérarchie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
class A
{
    public:
        virtual ~A();
};
class B : public A
{
    public:
        virtual ~B()
};

Si tu as une collection de pointeurs vers A comme, par exemple,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std:vector<A *> tab;

et que tu veux accéder à une fonction membre n'existant que pour B(en étant sur que ton objet est bel et bien de type B), tu utilisera un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
B * monB = dynamic_cast<B*>(tab[N]); // récupère un pointeur vers l'objet 
                                     // de type B, NULL si ce n'est pas un B
monB->methodePropreAuxB();

[IsraGab]

Ok,
Je suis daccord dans le cas ou j'utilise un dynamic_cast.
Mais j'avais compris d'apres cet exemple que meme sans ce casting cela aurait été possible.

Et, à partir du moment ou j'utilise cette fonction de cating "dynamique", cela prouve bien que le C++, utilise un typage statique, non? La conversion se fait a la compilation?
Ou quoi que comme on utilise des pointeurs, il est possible que cela soit fait a l'execution?!
...Bref je sais pas trop

[skeud]

Tu peux aussi le faire en mettant tes methode en virtual, tres tres pratique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
class A
{
  virtual void affiche()
  {
    std::cout<<"A"<<std::endl;
  }
};
 
class B : public A
{
  void affiche()
  {
    std::cout << "B" << std::endl;
  }
}
 
int main()
{
  A typeA;
  B typeB;
 
  //affiche 'A'
  A.affiche();
  //affiche 'B'
  B.affiche();
}

J'utilise sa pour faire mes programme avec un chargement de module externe, par librairie Dynamique donc c'est pas gérer au moment de la compilation