Discussion :

[Xavier]

Bonjour à tous,
je suis en train de migrer une app C++Builder 32bits vers Sydney 10.4 en 64bits.
Voici un cas de plantage de compilation ou d'exécution lors du passage d'une valeur en doube vers int:
Voici le code ci-dessous:

Code :

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

1
2
3
double tmpVal64 = 1E100;
int kk; 
kk = tmpVal64;  // ou kk = (int) tmpVal64;

Ce code a été testé sous 32bits, tout est OK (bien sure que la valeur kk n'est pas correct, mais on s'enfiche car une valeur 1e100 est une exception, au moins pas de plantage).
Dans le système Sydney 10.4, 64bits, ce sera un plantage!
Mon code n'est pas très professionnel, mais il tourne OK depuis 15 ans.
Pour le moment, je fais une limite de valeur tmpVal < 1e9 (max d'un int).
Est-ce qu'il y a d'autre méthode professionnelle permettant d'éviter ce plantage sous 64 bits, svp.
Merci d'avance de votre aide.
Xavier

[DjmSoftware]

salut
en utilisant la gestion des exceptions avec

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
try
{
 
// ton code pouvant provoquer des exceptions ici
 
 
}
catch (Exception&E)
{
 
// traitement des exceptions Ici
 
}

par ailleurs un nouveau type de données est apparu avec les version 64 bits
ils s'agit de

typedef long long Int64;

plage de donnée -2^63 à 2^63-1.

aide ici

tu peux utiliser également la librairie boost exemple ici



cdlt

[dalfab]

Bonjour,

Code :

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

1
2
double tmpVal64 = 1E100;
int kk = tmpVal64;

est un "undefined behavior" donc le compilateur peut l'accepter ou pas. Et à l'exécution tout est possible, ça peut faire fumer le PC, éteindre la tour Eiffel ou autre, en tout cas aucune exception n'est prévue pour cela. Si le compilateur l'acceptait avant on ne peut pas le blâmer, mais la refuser désormais est tout aussi correct.

Quand au fait que ça ne plantait pas c'était donc un bug enfoui. Pour éviter le plantage, il ne faut pas faire cela! Tous les "undefined behavior" ont un comportement aléatoire, on ne peut donc pas en attendre un comportement.

A noter que la norme a évolué, ainsi la ligne suivante est désormais interdite à la compilation

Code :

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

constexpr int kk = 1e100; // conversion impossible d'une constante

Un autre exemple de code qui a souvent marché mais qui peut aussi planter un programme:

Code :

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

1
2
double  a;
double  b = a; // copie d'une donnée non initialisée

[DjmSoftware]

J’aime particulièrement ta citation

est un "undefined behavior" donc le compilateur peut l'accepter ou pas. Et à l'exécution tout est possible, ça peut faire fumer le PC, éteindre la tour Eiffel ou autre, en tout cas aucune exception n'est prévue pour cela. Si le compilateur l'acceptait avant on ne peut pas le blâmer, mais la refuser désormais est tout aussi correct.

Il est à noter que ce n’est pas parce qu’un code a fonctionné qu’il fonctionnera toujours, la plus part des compilos sont mis à jour avec les nouvelles évolutions des languages et également corrigés.

Bien cordialement

[Xavier]

Merci tous les deux!
J'apprends des choses sans arrêt.
Bien cordialement
Xavier

[Xavier]

J'ai fait une fonction très artisanale:

Code :

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

1
2
3
4
5
6
7
8
9
 
int DoubleToInt32(double inValue)
{
	if (inValue < -1E9) return(-1E9);
 	else 
        if (inValue > 1E9) return (1E9);
        else
	return ((int) inValue);
}

[dalfab]

On peut créer un Int32 qui va saturer à ses limites si on lui en demande un peu trop.

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
38
39
40
class SafeInt32 {
public:
	template<typename T, std::enable_if_t<
		   std::is_arithmetic_v<T>
		&& (   std::numeric_limits<T>::max() > std::numeric_limits<std::int32_t>::max()
		    || std::numeric_limits<T>::min() < std::numeric_limits<std::int32_t>::min() )
		,int> =0>
	constexpr SafeInt32( T x )noexcept {
		if constexpr ( std::is_unsigned_v<T> ) { // c'est juste pour éviter un warning comparaison signed/unsigned
			if ( x > static_cast<std::uint32_t>(std::numeric_limits<std::int32_t>::max()) )
				val_ = std::numeric_limits<std::int32_t>::max();
			else
				val_ = static_cast<std::int32_t>(x);
		}
		else { // on se limite à ce qui tiens dans dans les bornes
			if ( x > std::numeric_limits<std::int32_t>::max() )
				val_ = std::numeric_limits<std::int32_t>::max();
			else if ( x < std::numeric_limits<std::int32_t>::min() )
				val_ = std::numeric_limits<std::int32_t>::min();
			else
				val_ = static_cast<std::int32_t>(x);
		}
	}
 
	template<typename T, std::enable_if_t<
		   std::is_arithmetic_v<T>
		&& std::numeric_limits<T>::max() <= std::numeric_limits<std::int32_t>::max()
		&& std::numeric_limits<T>::min() >= std::numeric_limits<std::int32_t>::min()
		,int> =0>
	constexpr SafeInt32( T x )noexcept : val_{static_cast<std::int32_t>(x)} {
	}
 
	constexpr SafeInt32()noexcept = default;
 
	constexpr operator std::int32_t()const noexcept {
		return  val_;
	}
private:
	std::int32_t  val_{};
};

Ainsi:

Code :

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

1
2
SafeInt32  a{1e100};  // => 2147483647
SafeInt32  b{-0xffffffffffffLL};  // => -2147483648

[Xavier]

Merci dalfab,
je vais essaie d'implanter ta classe car elle est beaucoup plus complète que ma fonction artisanale.
Cordialement
Xavier