Discussion :

[minnesota]

Salut,

Je voudrais faire un fichier templates pour étendre les possibilités de sizeof, sauf si ça existe déjà (j’ai bien vu typeid de "typeinfo", mais c'est résolu à l'exécution, je crois) par taille du type de base, en taille-mémoire, en nombre d'éléments.

J'ai juste fait ça pour l'instant. Mais avant de continuer, j'aimerais savoir s'il existe quelle chose qui va dans ce sens.

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
template <typename T>
size_t sizeof_type(const T *base_variable){
  return sizeof(T);
}
 
template <typename T>
size_t sizeof_type(const T &base_variable){
  return sizeof(T);
}
 
 
int main(){
 
  int t;
  wcout<< sizeof(int)<< endl;
  wcout<< sizeof_type(t)<< endl;
 
...
}

[cob59]

J'ai l'habitude de me faire des petites routines pour manipuler plus facilement les tableaux C. Si ça peut aider...

Code :

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

1
2
3
4
5
6
 
template <typename Type, size_t Size>
inline size_t length_of(const Type(&)[Size]) { return Size; }
 
template <typename Type, size_t Size>
inline Type* end_of(Type(&a)[Size]) { return a + length_of(a); }

Code :

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

1
2
3
4
5
 
int tab[42];
 
// tab peut changer de taille sans perturber cet appel
std::sort( tab, end_of(tab) );

[minnesota]

Salut,

Merci pour ta réponse. Tu penses qu'on pourrait se faire un header complet pour lequel une simple inclusion serait suffisante pour bénéficier de ces facilités, comme il ne semble pas exister quelque chose de fait et éprouvé ?

[cob59]

En fait je me demande si ça n'existe pas déjà dans Boost.Fusion.

[Flob90]

Bonjour,

Je suis pas certain d'aboir compris ce que tu cherches à faire, mais ton exemple ne sert à rien :

Code :

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

1
2
3
4
5
6
7
8
 
#include<iostream>
 
int main() 
{
	int t;
	std::cout << sizeof(t);
}

Est parfaitement valide.

Les fonctions présentées par cob59 sont déjà plus utiles. En ajoutant un constexpr en C++11.

Je ne crois pas qu'il y est directement cette fonction dans boost (peut-être dans un scope detail). Cependant ce n'est pas si utile :
-> Si on veut travailler sur un tableau statique alors on écrit directement :

Code :

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

1
2
3
 
template<class T, size_t N>
R foo(T (&tab)[N]) { /*code*/ }

-> Sinon il y a ca : http://www.boost.org/doc/libs/1_49_0...ce/extent.html qui est maintenant présent dans la biblitohèque standard (dans <type_traits>).

[Ekleog]

Je crois que l'objectif est de déterminer la taille totale prévue à l'exécution, style :

Code :

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

1
2
3
4
5
6
7
8
9
10
class A {
   int a;
   double b;
};
class B {
   A * a;
};
 
// ...
full_sizeof(B()); // sizeof(B) + sizeof(A) (car B contient un A*)

Sauf que, dès qu'il y a un membre privé, ce sera impossible en non-intrusif. (Enfin, je crois !)

[minnesota]

Je viens de regarder la doc boost, y'a bien quelque chose sur les array (boost::array), mais j'ai rien vu qui va dans le sens de la question.

[Flob90]

Tu veux faire quoi exactement ? Un exemple parlant de ce que tu voudrais ?

Pour boost, comme je l'ai dit, il y a peut-être ce que proposait cob59 dans un des scopes detail, mais il faut fouiller (il s'agit des scopes utilisés pour l'implémentation interne de boost, tu trouveras pas tout ce qui est dedans sans aller voir directement dans les sources).

PS: Le but de boost::array ce n'est pas de proposer des outils pour les C-array, mais de proposer des tableaux statiques dans un style S(T)L, ce qui est maintenant dans la bibliothèque standard, std::array.

[minnesota]

Ce que je voudrais, c'est une facilité qui me retournerait la taille du type d'un objet, que ce soit une variable simple, un tableau, un pointeur sur quelque chose, une référence. C'est pour ça que j'avais parlé de typeid, et bien sûr, que ça fonctionne aussi bien pour les allocations dynamiques.

Code :

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

1
2
3
4
  wchar_t* t1= new wchar_t[10];
  wcout<< sizeof(wchar_t)<< endl;
  wcout<< sizeof_type(t1)<< endl;
  delete [] t1;

Merci de ton intérêt.

[Flob90]

C'est donc ce que disais Ekleog ? Dans ce cas, comme il l'a dit, il n'y a peut-être pas de solution non-intruisive.

Tu veux faire ca juste pour expériementer ou tu as un réel besoin ? Si il y a un besoin, tu pourrais détailler le contexte ?

[minnesota]

Non, c'est juste pour une question de facilité et de flexibilité. ça fait plusieurs années que j'ai pas codé, je dois pratiquement tout réapprendre. J'ai également décidé de passer totalement à l'Unicode, j'en parle plus en détail dans d'autres sujets.

Le contexte, c'est que si je décide de changer le type d'une variable (char -> wchar_t ou vice versa, par exemple), j'aimerais que les autres variables dont elles dépendent s'auto-ajustent, mais aussi le positionnement dans les itérations, ect. Mais effectivement, à ce stade c'est de l'expérimentation.

Code C++ :

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

1
2
  char wc[]={0x0,0x42, 0x0,0x43, 0,0x44, 0,0x45, 0,0x46};// 0,0}
  wchar_t ws[sizeof(wc)/sizeof(wchar_t)+1]={0};

L'exemple veut pas se colorier

[Flob90]

D'accord, dans ce cas tu peux jouer avec les typedef et les classes de traits.

Disons que j'ai :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
//Deux variables du même type
TypeA varA1;
TypeA varA2;
 
//Une variable d'un type lié au type de varA1
TypeB varB;
 
//Une variable lié au type TypeA mais pas à une variable
TypeC varC;

Tu pourrais écrire :

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
28
29
30
31
32
33
34
35
36
37
 
struct TypeA {};
struct TypeB {};
struct TypeC {};
 
//Quelques éléments préliminaires
 
//Un typedef pour définir le type de varA
//Nécessaire pour pouvoir lié à type au type d'une variable
typedef TypeA TypeVarA;
//A changer si on veut changer le type de la variable
 
//Deux classes de trait
template<class> struct TraitVarA;
//On lie un type au type de la variable grace au typedef
template<> struct TraitVarA<TypeVarA>
{ typedef TypeB type; };
//A changer si on veut changer le type lié
 
template<class> struct TraitTypeA;
//On lie directement à un type
template<> struct TraitTypeA<TypeA>
{ typedef TypeC type; };
//A changer si on veut changer le type lié
 
int main() 
{ 
	//Le code d'avant réécrit
	TypeVarA varA1;
	TypeA varA2;
 
	//Une variable d'un type lié au type de varA1
	TraitVarA<TypeVarA>::type varB;
 
	//Une variable lié au type TypeA mais pas à une variable
	TraitTypeA<TypeA>::type varC;
}

C'est un exemple peut-être un peu simpliste, mais l'idée est là. Tu rentres tout doucement dans la méta-prog (*) en allant dans cette voie. Du moins tu fait l'expérience de quelque chose que tu connais déjà :

-> Quand tu concois ton programme, tu définies les liens entre tes variables. Tu te retrouves souvent avec des indirections qui te permettent de changer l'implémentation sans changer l'interface.
-> C'est pareil en méta-prog, on réalise des opérations manipulant des types, il faut clairement définir les liens entre les types et au besoin passer par des "indirections" pour isoler l'interface de l'implémentation.

Quand tu concois un programme runtime, tu peux avoir une variable a avec une fonction membre foo qui va utiliser un sous-objet b travaillant avec d'autre sous-objets. Tu pourrais très bien faire que a travaille directement avec les sous-objets finaux, mais dans ce cas tu ne pourras plus changer l'implémentation de b qui peux servir ailleurs.

En méta-prog (*) c'est pareil, le typedef permet d'isoler l'interface ("le type de la variable") de son implémentation ("TypeA"). Je peux changer le type réel de la variable a sans affecter le reste du code. Sans lui les changements devrait se faire à de multiple endroit. Et on ne peut bien entendue pas directement changer la définition de TypeA, c'est bien le type de l'objet a qu'on veut modifier, et pas l'ensemble des objets de type TypeA.

Tes classes de traits peuvent aussi extraire des informations sur des types (et pas en associer arbitrairement), voir en calculer (à nouveau on rentre doucement dans la méta-prog (*)), grace aux spécialisations partielles. Par exemple je citais std::extent, elle permet de récupérer la n-dimension d'un tableau multi-dimensionnel.

(*) Ca reste "border-line".

[minnesota]

Oui oui, c'est la base de la sl comme "typedef basic_string<>"
Au temps pour moi. Merci.

Sinon, pour ce besoin de récupérer la taille du type, j'ai pensé (ton précédent message m'y a fait penser) à déclarer une variable simple juste avant celle d'un tableau par exemple ou un pointeur peu importe, ce qui me permettrait de ne pas avoir à descendre dans le code pour faire des modifications de type (ou cette variable simple aura place) je pense que de la sorte il y aura moins de risque d'oublis.

Code :

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

1
2
wchar_t typeof_pointer;
wchar_t* pointer= new wchart_t[5];

Une fois le chemin déblayé et les choses mieux encadrés, c'est pas encore évident (sans parler des Libs tierces), je verrais à faire quelque chose de plus élégant dans le sens de ce que tu suggères.

Merci à tous.

[Joel F]

Je vois pas l'interet de decreter que sizeof_type(T*) == sizeof(T).

[minnesota]

C'est la taille du type de l'objet, pas de l'objet lui-même, y'a pas d'égalité.