Quelques précisions. . .

**Array** · 28/09/2007, 23h18

Je crois bien que si.
Vois-le par toi même :

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
 
@echo off
Rem Intel(R) C++ Compiler for applications running IA-32
 
Rem Intel(R) C++ Compiler for applications running IA-32, Version 10.0.026
Rem Copyright (C) 1985-2007 Intel Corporation. All rights reserved.
 
if not defined MSVCDIR call "C:\Program Files\Microsoft Visual Studio\VC98\Bin\Vcvars32.bat"
 
SET ICPP_COMPILER10=C:\Program Files\Intel\Compiler\C++\10.0.026\

SET INTEL_SHARED=C:\Program Files\Fichiers communs\Intel\Shared Files
 
SET INTEL_LICENSE_FILE=C:\Program Files\Fichiers communs\Intel\Licenses
 
SET PATH=%ICPP_COMPILER10%\Ia32\Bin;%INTEL_SHARED%\Ia32\Bin;%PATH%
 
SET LIB=%ICPP_COMPILER10%\Ia32\Lib;%MSVCDIR%\Lib;%LIB%
 
SET INCLUDE=%ICPP_COMPILER10%\Ia32\Include;%MSVCDIR%\Include;%INCLUDE%

Ce code .BAT est iclvars.bat, que cmd.exe exécute lorsque lui-même est exécuté.

Ensuite :

Envoyé par INSTALL.htm

Software Requirements to Develop IA-32 Applications

* Microsoft Windows XP*, Windows Vista* or Windows Server 2003*.
Note: Microsoft Windows 98*, Windows 98 SE*, Windows Millennium Edition*, Windows 2000* and Windows NT* are not supported for product development
* One of the following Microsoft development products must be installed:
o Microsoft Visual C++ 6.0*
o Microsoft Visual Studio 98*
o Microsoft Visual C++ .NET 2003*, Standard edition or above
o Microsoft Visual Studio .NET 2003*, any edition, with Visual C++ component installed
o Microsoft Visual Studio 2005*, Standard edition or above, with Visual C++ component installed
o Microsoft Visual C++ 2005* Express Edition, supported for command-line development tool use only - the visual development environment is not supported with this edition
* For development on Windows Vista, only Microsoft Visual Studio 2005 is supported. This is a Microsoft restriction.
* If using Microsoft Visual C++ 2005 Express Edition, installation of the Windows Server 2003 R2 Platform SDK (Core SDK) is required for applications that make use of the Win32 API.
* Microsoft Visual Studio 2005 Premier Partner Edition is not supported for use with the Intel C++ Compiler. This is a Microsoft restriction.
* Use of command-line tools for building is supported only if one of the above required Microsoft development products is installed. The Microsoft Platform SDK alone is not sufficient.

Dans le fichier d'installation de ICC 10.0.026 [install.htm], on spécifie clairement que l'on doit avoir Microsoft Visual [quelquechose], comme Visual C++ 6.0.

Je désapprouve Intel cependant, car Microsoft a le don d'importuner ses consommateurs, en matière de C par exemple.
Mais étant donné que c'est l'OS de MS, probablement ces en-têtes sont-elles considérées comme la référence.

Cependant, j'ai testé GCC vs ICC. Je notice une grande différence de vitesse. Des fois jusqu'à plus de 45 secondes de différence!

Cordialement,

Array.

**Médinoc** · 29/09/2007, 00h57

Quelle version de Visual possèdes-tu ?
Et quelle version du SDK (si tu le sais) ?

**Array** · 29/09/2007, 04h14

Envoyé par médinoc

Quelle version de Visual possèdes-tu ?
Et quelle version du SDK (si tu le sais) ?

Visual C++ v6.0

Cependant, je crois que pour le C, c'est la même version que dans Visual C++ 98. Car le dossier contenant les fichiers d'en-tête se nomme VC98.

Je n'ai pas le SDK. Pas besoins, je n'utilise pas MS VC++ 2005 Express

**Array** · 29/09/2007, 06h20

Voilà j'ai encore un problème de conversion de format dans printf, cependant, celui-ci est plutôt spécial.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include <stdio.h>
 
int main(void) {
	long double x;
	x = 14.56;
	x *= 10000000000;
	printf("%Lf\n", x);
	return 0;
}

Lorsque je le compile avec le Compilateur Intel, pas de problème, aucune erreur, et le programme écrit le résultat voulu, soit "145600000000".

Cependant, avec MingW, le programme écrit :

-0.000000

J'ai beau chercher sur Google, je ne peux rien trouver, j'ai essayé tout, en anglais comme en français.
Tout ce que j'ai pu trouver est cette affirmation : "MingW is broken with long double numbers[...]".

Y aurait-il quelque chose à avoir avec MingW ou avec MSCVRT.DLL ?!

Merci & Cordialement,

Array

EDIT :

J'ai trouvé cette page, expliquant tout : http://www.mingw.org/MinGWiki/index.php/long%20double

**Médinoc** · 29/09/2007, 20h58

Envoyé par Array

Visual C++ v6.0

Cependant, je crois que pour le C, c'est la même version que dans Visual C++ 98. Car le dossier contenant les fichiers d'en-tête se nomme VC98.

VC98 == VC++6.
Donc, tes fichiers d'en-tête sont bel et bien trop vieux pour le type long long!

Je n'ai pas le SDK. Pas besoins, je n'utilise pas MS VC++ 2005 Express

Il y a forcément un SDK. Et même plusieurs, dans ton cas:

Le SDK de base, avec les headers et les bibliothèques statiques de la C Run-Time Library
Le PlatformSDK, dont une (vieille) version est livrée avec VC++6 (la dernière mise à jour qui soit officiellement compatible avec VC++6 est celle de Février 2003).

**Array** · 30/09/2007, 17h08

Donc, tu me conseillerais quoi!?

Microsoft VC++ 2005 !?
Car je me rend compte qu'en effet, VC98 est trèèès vieux, ainsi que VC++ 6.0.

Merci,

Array

**Array** · 03/10/2007, 17h55

Bonjour,

Je désirerais savoir si, dans les arguments de fonctions, on peut stocker une valeur quelconque de type integer, et ce, en la séparant chiffre par chiffre dans le tableau.

Par exemple :

Soit une déclaaration de fonction
[code]int fonction(type tableau[1000]);[code]

Ainsi, lorsque j'appelerais la fonction "fonction()" de la sorte :

Code :

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

fonction(7354);

Les quatres premiers index du tableau seraient occupée :

tableau[0] == 7;
tableau[1] == 3;
tableau[2] == 5;
tableau[3] == 4;

Un peut comme avec les tableau de type char, lorsque l'on appelle une fonction en lui donnant une chaîne de caractère.

Merci,

Array

**Thierry Chappuis** · 03/10/2007, 20h18

Non, on ne peut pas! Mais c'est facile à faire...

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#define NB_ELEMS(a) ( sizeof (a) / sizeof *(a) )
 
static size_t decompose_int(int val, int tab_out[], size_t taille);
 
void fonction(long val)
{
    int tableau[15] = {0};
    size_t i;
 
    if (decompose_int(val, tableau, NB_ELEMS(tableau)) != 0)
    {
        /*-tc- exemple de code */
        for ( i = 0; tableau[i] != -1; ++i)
        {
            printf("%d\n", tableau[i]);
        }
    }
}
 
static size_t decompose_int(int val, int tab_out[], size_t taille)
{
    size_t err = 0;
    size_t n_digits = 1;
    int n = val;
 
    if (val < 0)
    {
        val = -val;
    }
 
    while (n > 10)
    {
        n_digits++;
        n = n / 10;
    }
 
    if (n_digits < taille)
    {
        n = val;
        tab_out[n_digits] = -1;
 
        while (n_digits > 0 && n > 0)
        {
            tab_out[--n_digits] = n % 10;
            n = n / 10;
        }
    }
    else
    {
        err = 1;
    }
 
    return err;
}

Thierry

**Array** · 03/10/2007, 23h06

Merci Thierry. Cependant, [lol] j'avais déjà pensé à cela. c'est à dire qu'on divise par 10 selon où on est rendu, puis on effectue une soustraction grâce à la troncature en on obtiens notre réponse.

Cependant, c'est une tout autre histoire pour ces chers petits nombres à virgule...
Car, au fur et à mesure qu'on les modifie, ils se corrompent...

**Thierry Chappuis** · 04/10/2007, 01h14

Envoyé par Array

Merci Thierry. Cependant, [lol] j'avais déjà pensé à cela. c'est à dire qu'on divise par 10 selon où on est rendu, puis on effectue une soustraction grâce à la troncature en on obtiens notre réponse.

Cependant, c'est une tout autre histoire pour ces chers petits nombres à virgule...
Car, au fur et à mesure qu'on les modifie, ils se corrompent...

Tu peux te baser sur la fonction decompose_int(). Voici un petit exemple:

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include <stdio.h>
#include <math.h>
 
#define NB_ELEMS(a) ( sizeof (a) / sizeof *(a) )
 
static int decompose_double(double val, int int_part[], size_t taille_ip,
                            int dec_part[], size_t taille_dp, size_t precision);
static size_t decompose_int(int val, int tab_out[], size_t taille);
static void afficher(int tab[], size_t taille);
 
int main(void)
{
    int intp[10] = {0};
    int decp[10] = {0};
    size_t precision = 5;
 
    if (decompose_double(3.1416, intp, NB_ELEMS(intp), decp, NB_ELEMS(decp), precision) == 0)
    {
        afficher(intp, NB_ELEMS(intp));
        printf(".");
        afficher(decp, NB_ELEMS(decp));
        printf("\n");
    }
 
    return 0;
}
 
static int
decompose_double(double val, int int_part[], size_t taille_ip, int dec_part[],
                 size_t taille_dp, size_t precision)
{
    int err = 0;
 
    if (taille_ip > 0 && taille_dp > 0 && taille_dp > precision)
    {
        int integer_part = (int) val;
        int decimal_part = (int) ((val - floor(val)) * pow(10, precision));
 
        if (decompose_int(decimal_part, dec_part, precision + 1) != 0 ||
                decompose_int(integer_part, int_part, taille_ip) != 0)
        {
            err = 2;
        }
    }
    else
    {
        err = 1;
    }
    return err;
}
 
static size_t
decompose_int(int val, int tab_out[], size_t taille)
{
    size_t err = 0;
    size_t n_digits = 1;
    int n = val;
 
    if (val < 0)
    {
        val = -val;
    }
 
    while (n > 10)
    {
        n_digits++;
        n = n / 10;
    }
 
    if (n_digits < taille)
    {
        n = val;
        tab_out[n_digits] = -1;
 
        while (n_digits > 0 && n > 0)
        {
            tab_out[--n_digits] = n % 10;
            n = n / 10;
        }
    }
    else
    {
        err = 1;
    }
 
    return err;
}
 
static void
afficher(int tab[], size_t taille)
{
    if (tab != NULL)
    {
        size_t i;
 
        for (i = 0; i < taille && tab[i] != -1; ++i)
        {
            printf("%d", tab[i]);
        }
        fflush(stdout);
    }
}

Thierry

**Array** · 08/10/2007, 00h46

Cela fonction xD.
Même si j'ai mis cinq minues à comprendre ta fonction.
Merci

Oh, au fait :

Je voudrais savoir si l'on peut utiliser des nombres allant à 128 bit...
les "long long" sont 64 bits...
Qu'en est-il pour les 128 bits?
Probablement pas "long long long", cela ne fonctionna pas sur mes compilateurs en tout cas.

Merci,

Array

**Thierry Chappuis** · 08/10/2007, 01h01

Envoyé par Array

Cela fonction xD.
Même si j'ai mis cinq minues à comprendre ta fonction.
Merci

Oh, au fait :

Je voudrais savoir si l'on peut utiliser des nombres allant à 128 bit...
les "long long" sont 64 bits...
Qu'en est-il pour les 128 bits?
Probablement pas "long long long", cela ne fonctionna pas sur mes compilateurs en tout cas.

Merci,

Array

Sur les architectures que je connais, il n'existe pas d'entiers codés sur 128 bits (mais je n'en connais pas beaucoup).

Thierry

**Emmanuel Delahaye** · 08/10/2007, 10h38

Envoyé par Array

Je voudrais savoir si l'on peut utiliser des nombres allant à 128 bit...
les "long long" sont 64 bits...
Qu'en est-il pour les 128 bits?
Probablement pas "long long long", cela ne fonctionna pas sur mes compilateurs en tout cas.

Non. Une fois de plus, confusion. Pour un type donné, la norme ne donne pas de taille fixe. Elle donne une taille minimale garantie. Elle dit (avec d'autres mots, OK[1]) qu'un int fait au moins 16-bit, un long 32-bit et un long long 64-bit, mais rien n'empêche un int de faire 32-bit, un long 64-bit et un long long 128-bit. Ce n'est certes pas portable (pas plus que les int de 32-bit), mais si l'architecture le permet, c'est possible et les implémenteurs du C pour cette architecture ne s'en sont certainement pas privés.

-----------------------
[1] La norme définit des plages minimales de valeurs garanties

**Array** · 11/10/2007, 03h42

Bonjour,

Je désirerais que l'on m'apporte quelques précision sur un passage, très bref, de mon livre, que je ne comprends pas (j'en déduis que c'est du jargon informatique...).

Voici ce passage :

[...] La conversion d'un "char" en un "int" peut-elle donner un entier négatif? La réponse dépend de l'architecture de la machine utilisée. Sur certaines machines, un "char" dont le bit de poid fort est à 1 donnera un entier négatif (c'est le principe d'«extension de signe»). Sur d'autres, la conversion s'effectue en ajoutant des zéros à gauche du "char", ce qui donne toujours un "int" positif. [...]

J'ai surligné en rouge ce que je ne peut m'expliquer.

Que veut-il dire par "un bit de poid fort" !?
Qu'est-ce que l'extension de signe!?
Que veut-il dire par "la conversion s'effectue en ajoutant des zéros à gauche du "char" ?

Voilà,

Question de bien Comprendre,

Merci,

Array.

**Thierry Chappuis** · 11/10/2007, 08h19

Prenons par exemple le code suivant:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    char c = 'é';
    int code = c;
    printf("Le code du caractère \'%c\' est %d\n", c, code);
 
    return EXIT_SUCCESS;
}

qui affiche le message suivant sur ma console:

Code :

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

1
2
 
Le code du caractère 'é' est -23

En supposant un encodage iso-8859-1, le code du caractère 'é' est 233 (ou 0xE9), on a donc la représentation binaire suivante:

Code :

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

c: 11101001

La norme ne précise pas si un entier de type char est signé ou non. Ainsi, l'implantation a la liberté de trancher sur ce point et un char peut être signé ou non selon ton architecture et ton compilateur.

Imaginons qu'un char soit signé comme chez moi. La conversion de char à int se fait de la manière suivante:

Code :

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

code: (MSB) 11111111 11111111 11111111 11101001 (LSB)

où le byte de poids faible (least significant byte) est la valeur de c. On peut voir que lorsqu'un char est signé, la conversion utilise le bit de poids fort de c (qui vaut 1 dans notre cas) et le répète dans l'expansion afin d'obtenir un int codé (par exemple) sur 4 bytes. Ainsi, en supposant une représentation en complément à deux des entiers négatifs, on affiche la valeur de code qui est -23 (0xFFFFFFE9 = ~0x17 + 1).

Imaginons maintenant qu'un char soit non signé. On aura:

Code :

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

code: (MSB) 00000000 00000000 00000000 11101001 (LSB)

Dans ce cas, quelle que soit la valeur du bit de poids fort de c, l'expansion se fera avec des zéros et la valeur affichée par le programme ci-dessus sera:

Code :

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

Le code du caractère 'é' est 233

Pour expérimenter, tu peux jouer avec les opérateurs de conversion:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
/* affichage du code d'un caractère non-signe */
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    char c = 'é';
    int code = (unsigned char) c;
    printf("Le code du caractère \'%c\' est %d\n", c, code);
 
    return EXIT_SUCCESS;
}

et

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
/* affichage du code d'un caractère signe */
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    char c = 'é';
    int code = (signed char) c;
    printf("Le code du caractère \'%c\' est %d\n", c, code);
 
    return EXIT_SUCCESS;
}

J'espère que ça répond à ta question.

Thierry

**Médinoc** · 11/10/2007, 09h07

En fait, le fait que le type char soit signé ou non peut carrément dépendre des options passées au compilateur. Et tout ça, sans cesser de respecter la norme, puisqu'elle ne précise pas si les char sont signés ou non.

En fait, en C++, char, signed char et unsigned char sont bel et bien considérés comme trois types différents.

**Thierry Chappuis** · 11/10/2007, 10h57

Envoyé par Médinoc

En fait, le fait que le type char soit signé ou non peut carrément dépendre des options passées au compilateur. Et tout ça, sans cesser de respecter la norme, puisqu'elle ne précise pas si les char sont signés ou non.

En fait, en C++, char, signed char et unsigned char sont bel et bien considérés comme trois types différents.

De toute manière, comme le nature signée ou non signée d'un entier de type char est indéterminée, il ne faut pas faire de supposition sur le fait qu'un char est signé ou non. Ainsi, lorsqu'il est nécessaire de convertir un entier de type char en un entier de type int, je recommande de convertir explicitement le caractère en un (unsigned char) ou (signed char) avant la conversion. C'est par exemple la pratique recommandée lorsqu'on utilise des fonctions telle que toupper() ou tolower() déclarées dans le fichier d'en-tête standard ctype.h.

Thierry

**Array** · 17/10/2007, 23h55

Cher Thierry,

Ce que je n'arrive pas à saisir dans ta réponse [si précise soit-elle] : Comment 0xFFFFFFE9 peut donner -23 ?

Ce serait supposé de donner un nombre dans les dizaines de milliards!

Serais-ce que passé un certain nombre, on revient à zéro?
Merci de m'éclairer sur ce sujet.

Sincèrement,

Array

**PsychoH13** · 18/10/2007, 09h25

Il s'agit en fait de la représentation des nombres relatifs.
Tu as deux manières de représenter un nombre relatif, soit avec un bit de signe, soit avec un complément à deux.
Le bit de signe c'est très simple, pour trouver la valeur d'un nombre négatif, tu prends sa valeur absolue, et tu mets le bit de poids fort à 1, exemple (sur 8 bits) :
Valeur à trouver -12 :
Valeur absolue (12) en binaire : 0000 1100 (0x0C)
Valeur avec bit de signe : 1000 1100 (0x8C)
Voilà ce que ça donne.

Le problème de cette technique c'est que l'addition bit-à-dit des nombres est plus difficile, par exemple -12 + 12 = 0000 1100 + 1000 1100 = 1001 1000 ce qui donne -24...

Alors on a une autre technique qui est le complément à deux et qui est la technique préférée car plus pratique. Elle se fait en 3 étapes, on prend à nouveau la valeur absolue, on inverse tous les bits et on ajoute 1 en laissant tomber les bits en trop. Voilà ce que ça donne :
Valeur à trouver -12 :
Valeur absolue (12) en binaire : 0000 1100
Inversion des bits : 1111 0011
On ajoute un : 1111 0100, donc la valeur -12 sera représentée par 0xF4 sur 8 bits. Et quand tu ajoutes -12 et 12, ça donne :

Code :

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

1
2
3
      0000 1100
+     1111 0100
= (1) 0000 0000

Le bit entre parenthèse est simplement ignorée, et tu peux ainsi voir que l'addition est beaucoup plus simple. Et avec ce système, tu peux voir que :

La valeur maximale est 127 : 0111 1111
La valeur minimale est -128 : 1000 0000
La valeur de -1 est : 1111 1111

Ça c'est sur 8 bits, mais le principe est le même sur 16, 32, 64, etc.
la technique préférée c'est la deuxième, mais ça peut changer selon les implémentations.

**Thierry Chappuis** · 18/10/2007, 17h59

Envoyé par PsychoH13

Il s'agit en fait de la représentation des nombres relatifs.
Tu as deux manières de représenter un nombre premier,

Rien à voir avec les nombres premiers

Envoyé par PsychoH13

soit avec un bit de signe, soit avec un complément à deux.

Certaines architectures utilisaient également le complément à un, mais elles se font rares aujourd'hui et le complément à deux est de plus en plus utilisé.

Thierry

Quelques précisions. . .

C

Discussions similaires

Partager

Partager