Discussion :

[CedricMocquillon]

Bonjour à tous,

Je souhaite écrire une fonction qui réalise des vérifications à la compilation mais j'avoue ne pas voir comment m'y prendre: idéalement je voudrais que ma fonction prenne un paramètre (par exemple un int) et que je puisse faire des assertions statique en fonction de si ce paramètre est connu à la compilation (et vérifie certaines propriétés).
Un exemple valant (j'espère!) plus qu'un long discours, voilà en gros ce que je voudrais faire (les commentaires dans le code expliquent mon intention):

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>
void f(T* data, int taille) {
    //assert statique si taille n'est pas connue à la compilation ou si elle est différente de sizeof(T);
}
 
int main()
{
    int i=0;
    f(&i, sizeof(i)); //ok ça passe, taille est connue à la compilation est vaut sizeof(T)
    f(&i, sizeof(long)); //ko, taille est connue à la compilation mais ne vaut pas sizeof(T)
    f(&i, i); //ko, taille n'est pas connue à la compilation
}

Je ne sais même pas en fait si c'est possible en C++ ^^!
Merci pour votre aide

[bacelar]

Votre exemple est absurde.
Pourquoi demander un paramètre supplémentaire quand le code peut le déterminer de manière fiable ?

Ici un exemple de static_assert avec des sizeof(T):
http://stackoverflow.com/questions/1...-static-assert

[CedricMocquillon]

C'est vrai que c'est pas évident sur un exemple "hors sol". Mon cas est sur du code legacy: j'ai une fonction f qui peut être "unsafe" si le paramètre taille ne correspond pas à sizeof(T) mais je n'ai pas forcément accès au code source qui utilise la fonction f.
J'ai donc une version "safe" qui effectivement le prend pas de paramètres taille mais mon problème est pour les version "déjà dans la nature":
L'idée était donc d'informer ceux utilisant f avec une taille qui ne vaut pas sizeof(T) que c'est un comportement dangereux et que dans ce cas il.
En gros faire une partie à la compilation de ce qui est fait dans mon implémentation actuelle au runtime:

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>
void safe_f(T Data) {
	return unsafe_f(sizeof(*Data), (void*)Data);
}
 
void unsafe_f(ulong Len, void* pData);
 
template<typename T>
void legacy_f(ulong Len, T Data) {
	assert(Len == sizeof(*Data)); //ici ça devrait être détecté à la compilation si Len est connu à la compile et si Len est != de sizeof(*Data)
	return unsafe_f(Len, (void*)Data);
}

[koala01]

Salut,

A vrai dire, l'une des choses dont le compilateur a besoin pour pouvoir générer le code binaire exécutable, c'est de connaitre le nombre de bytes nécessaire à la représentation des types manipulés : il faut bien pouvoir s'assurer que les données seront placées en mémoire et qu'elles n'empiéteront pas les unes sur les autres.

L'opérateur sizeof fournit donc bel et bien ce qu'il convient d'appeler une constante de compilation, dans le sens où... la taille représentée (en nombre de bytes) par la valeur renvoyée par cet opérateur est... connue à la compilation.

La seule chose, c'est qu'il faut que cette valeur soit également perçue comme étant une constante de compilation si tu veux pouvoir vérifier une assertion statique. Ainsi, un code proche de

Code :

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

1
2
3
4
5
6
7
void foo(size_t i){
    static_assert(i>4,
                  "i doit permettre au minimum la representation d'un int");
}
int main() {
    foo(sizeof(int));
}

(qui n'est en définitive que la simplification à l'extrême de ton propre exemple) sera refusé au motif que

Code :

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

D:\partage\projects\test\main.cpp|4|error: non-constant condition for static assertion|

non pas parce que sizeof(int) n'est pas une constante de compilation, mais bien parce que le paramètre i (qui prend la valeur de cette constante de compilation) n'est pas considéré comme tel.

Par contre, vu que tous les types de données sont forcément en partie identifiés par le nombre de bytes nécessaires à leur représentation en mémoire, un code proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template <typename T>
void foo(T t){
    static_assert(sizeof(T)>sizeof(int),
                  "i doit permettre au minimum la representation d'un int");
}
int main() {
    char c;
    foo(c); // appelle foo(char) : refusé sizeof(char)< sizeof(int)
    size_t i;
    foo(i); // appelle foo(int) : autorirsé sizeof(size_t) > sizeof(int)
}

la ligne 8 (foo(c);) sera bel et bien refusée à la compilation parce que... l'assertion imposée (aux lignes 3 et 4) n'a pas pu être vérifiée.

[CedricMocquillon]

En fait je pensais que constexpr (sans avoir pris le temps de bien étudier comment on s'en sert je l'avoue) permettait ce genre de "trucs", i.e. si on a toute connaissance à la compilation faire un truc (dans mon cas soit failer, soit appeler la version unsafe car on est sûr que tout est ok) sinon faire un autre truc (dans mon cas faire un check mais cette fois ci au runtime).

[Pyramidev]

Bonjour,

Une fonction constexpr peut lancer une exception. Si on force à la compilation l'expansion d'une fonction constexpr et que cela lance une exception, cela provoque une erreur de compilation.

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
// Testé avec GCC 6.3.0
 
#include <iostream>
 
constexpr int unsafe_f(unsigned long Len, void* pData)
{
	// Attention, ici, on ne peut pas appeler de fonction non constexpr.
	return 0;
}
 
template<typename T>
constexpr int legacy_f(unsigned long Len, T* Data) {
	if(Len != sizeof(*Data))
		throw std::logic_error("Error in legacy_f: Len != sizeof(*Data).");
	return unsafe_f(Len, (void*)Data);
}
 
int main()
{
	try {
		int var = 20;
		int test1 = legacy_f(5, &var);           // Compile et lance une exception au runtime.
		constexpr int test2 = legacy_f(5, &var); // Erreur de compilation : lance une exception à la compilation.
	} catch(const std::exception& e) {
		std::cout << e.what();
	}
	return 0;
}

Mais le code que je viens d'écrire ne peut fonctionner que si unsafe_f est constexpr, ce qui est contraignant.

[CedricMocquillon]

Super! Merci Pyramidev c'est à ça que je pensais; bon par contre pour mon cas d'usage c'est "mort" car unsafe n'appelle pas que des fonctions constexpr mais par contre c'était bien l'idée.
Merci beaucoup à tous, vous êtes vraiment forts!