Quelques précisions. . .

**Array** · 05/12/2007, 03h17

Bonjour,

Je voudrais savoir ce que signifie "inline".

Lorsque j'exécute le script configure de GMP, voilà ce que j'obtiens >

Code :

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

1
2
3
 
configure: WARNING: gmp.h doesnt recognise compiler "__inline", inlines will be u
navailable

Merci,

Sincèrement,

Array

**Thierry Chappuis** · 05/12/2007, 08h25

Envoyé par Array

Bonjour,

Je voudrais savoir ce que signifie "inline".

Lorsque j'exécute le script configure de GMP, voilà ce que j'obtiens >

Code :

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

1
2
3
 
configure: WARNING: gmp.h doesnt recognise compiler "__inline", inlines will be u
navailable

Merci,

Sincèrement,

Array

Avec une fonction inline, chaque appel sera remplacé à la compilation par le code de la fonction, un peu comme avec une macro mais sans inconvénients de la macro et en permettant notamment la vérification des types des variables passées en argument.

Je n'ai pas eu cet avertissement lors de la compilation que j'ai faite de gmp.

Thierry

**Médinoc** · 05/12/2007, 09h20

__inline est une extension de Visual C++ pour des fonctions inline en C (car le mot-clé inline n'était pas supporté en C avant C99, sauf en tant qu'extension GNU).

Depuis, C99 est sorti, mais comme Micro$oft s'assoit dessus...

**Array** · 07/12/2007, 18h38

Bonjour,

Tout d'abord, merci pour ces deux réponsses précédentes. Il esst à noter que j'obtiens ces erreurs par le fait que je passe l commande 'CC=cl' au script configure.

J'ai jeté un coup d'oeil au code source de GMP.
En fait, je suis curieux de savoir comment peut-on créer un nouveau type?

J'attire votre attention sur ce snippet :

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
 
typedef struct
{
  int _mp_prec;			/* Max precision, in number of `mp_limb_t's.
				   Set by mpf_init and modified by
				   mpf_set_prec.  The area pointed to by the
				   _mp_d field contains `prec' + 1 limbs.  */
  int _mp_size;			/* abs(_mp_size) is the number of limbs the
				   last field points to.  If _mp_size is
				   negative this is a negative number.  */
  mp_exp_t _mp_exp;		/* Exponent, in the base of `mp_limb_t'.  */
  mp_limb_t *_mp_d;		/* Pointer to the limbs.  */
} __mpf_struct;
 
/* typedef __mpf_struct MP_FLOAT; */
typedef __mpf_struct mpf_t[1];

Je ne sais pa comment bien posser ma question, mais comment mpf_t peux devenir un typee pour les nombres à virgule!? Ce n'est qu'une simple structure!

S.v.p. éclairez-moi...

Merci,

Sincèrement,

Array

**Thierry Chappuis** · 09/12/2007, 16h27

Que veux-tu dire par "ce n'est qu'une simple structure". L'usage de structures permet de programmer ce qu'on appelle des types abstraits de données (ou TAD) qui sont outils d'abstraction puissant. Je ne comprends pas le sens de ta question. Peux-tu préciser?

Thierry

**Array** · 12/12/2007, 01h01

Envoyé par Thierry Chappuis

L'usage de structures permet de programmer ce qu'on appelle des types abstraits de données (ou TAD) qui sont outils d'abstraction puissant.

Tu y as répondu malgré toi.

Donc, les structures peuvent être utilisées pour faire des type 'artificiels'?

Quel est le principe du TAD? Est-ce compliqué?

**Thierry Chappuis** · 12/12/2007, 08h32

Envoyé par Array

Tu y as répondu malgré toi.

Donc, les structures peuvent être utilisées pour faire des type 'artificiels'?

Quel est le principe du TAD? Est-ce compliqué?

Voici un lien que t'explique cela en détail. N'hésite pas à poser des questions si tu ne comprend pas: http://emmanuel-delahaye.developpez....its-donnees-c/

En gros, un type abstrait de donnée désigne l'ensemble formé par une structure de donnée et les opérations qui y sont associées. Voyons ensemble l'exemple d'un type Point_s déclaré par la structure suivante:

Code :

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

1
2
3
4
struct Point__ {
    double x;
    double y;
};

On désire lui associer un certains nombre d'opérations comme, par exemple, créer, détruire, déplacer, afficher. Pour cela, on utilise des fonctions qui prennent, en premier argument, un pointeur sur l'objet de type Point_s à manipuler. Ces fonctions forment l'interface. On n'accède jamais directement aux données de la structure, on se contente d'appeler les fonctions proposées par l'interface. Ainsi on a:

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
#include <stdio.h>
#include <stdlib.h>
 
typedef struct Point__ Point_s;
 
struct Point__ {
    double x;
    double y;
};
 
/* -tc- constructeur: permet de creer un objet de type Point_s */
Point_s *point_creer(double x, double y)
{
    Point_s *p_self = NULL;
 
    /* -tc- allocation de la memoire necessaire pour un point */
    p_self = malloc(sizeof *p_self);
    if (p_self != NULL)
    {
        static Point_s tmp = {0.0, 0.0};
        *p_self = tmp;
 
        /* -tc- initialisation des donnees membres */
        p_self->x = x;
        p_self->y = y;
    }
 
    return p_self;
}
 
/* -tc- destructeur: permet de detruire un objet de type Point_s */
void point_detruire(Point_s **const pp_self)
{
    if (pp_self != NULL && *pp_self != NULL)
    {
        free(*pp_self), *pp_self = NULL;
    }
}
 
void point_deplacer(Point_s *const p_self, double delta_x, double delta_y)
{
    if (p_self != NULL)
    {
        p_self->x += delta_x;
        p_self->y += delta_y;
    }
}
 
/* -tc- affiche un objet de type Point_s */
void point_afficher(Point_s const *const p_self)
{
    if (p_self != NULL)
    {
        printf("Point(%.2f, %.2f)\n", p_self->x, p_self->y);
    }
}
 
int main(void)
{
    Point_s *p = point_creer(10.2, 22.3);
    point_afficher(p);
    point_deplacer(p, 5, 5);
    point_afficher(p);
    point_detruire(&p);
 
    return 0;
}

Dans la pratique, on sépare évidamment l'implantation du TAD (notre type Point_s) et le code client (celui qui utilise notre type Point_s i.e. la fonction main()). La compilation séparée est parfaitement adaptée ici. Ainsi, on déplace l'implantation de notre TAD dans un fichier point.c:

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
/* fichier d'implantation du TAD Point_s: point.c */
#include <stdio.h>
#include <stdlib.h>
#include "point.h"
 
struct Point__ {
    double x;
    double y;
} Point_s;
 
/* -tc- constructeur: permet de creer un objet de type Point_s */
Point_s *point_creer(double x, double y)
{
    Point_s *p_self = NULL;
 
    /* -tc- allocation de la memoire necessaire pour un point */
    p_self = malloc(sizeof *p_self);
    if (p_self != NULL)
    {
        static Point_s tmp = {0.0, 0.0};
        *p_self = tmp;
 
        /* -tc- initialisation des donnees membres */
        p_self->x = x;
        p_self->y = y;
    }
 
    return p_self;
}
 
/* -tc- destructeur: permet de detruire un objet de type Point_s */
void point_detruire(Point_s **const pp_self)
{
    if (pp_self != NULL && *pp_self != NULL)
    {
        free(*pp_self), *pp_self = NULL;
    }
}
 
void point_deplacer(Point_s *const p_self, double delta_x, double delta_y)
{
    if (p_self != NULL)
    {
        p_self->x += delta_x;
        p_self->y += delta_y;
    }
}
 
/* -tc- affiche un objet de type Point_s */
void point_afficher(Point_s const *const p_self)
{
    if (p_self != NULL)
    {
        printf("Point(%.2f, %.2f)\n", p_self->x, p_self->y);
    }
}

On créer un fichier d'en-tête pour permettre au code client d'utiliser notre type Point_s:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
/* interface du type Point_s: point.h */
#ifndef H_TC_POINT__
#define H_TC_POINT__
 
typedef struct Point__ Point_s;
 
Point_s *point_creer(double x, double y);
void point_detruire(Point_s **const pp_self);
void point_deplacer(Point_s *const p_self, double delta_x, double delta_y);
void point_afficher(Point_s const *const p_self);
 
#endif /* guard H_TC_POINT__ */

Comme on peut le voir dans ce fichier d'en-tête, le client ne sait rien de la structure interne du type Point_s. Il l'utilise comme un type opaque et appelle les fonctions de son interface pour réaliser des opérations. Voici ce que devient le code client (main.c):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "point.h"
 
int main(void)
{
    Point_s *p = point_creer(10.2, 22.3);
    point_afficher(p);
    point_deplacer(p, 5, 5);
    point_afficher(p);
    point_detruire(&p);
 
    return 0;
}

N'hésite pas à poser des questions.

Thierry

**Array** · 14/12/2007, 03h03

Bonjour,

Je remercie Thierry pour la réponse précédente.
Donc, j'en déduis que ce qui constitue une grade partie du TAD est l'interface.

Ce sujet m'a emmené à m'informer sur d'autres aspects du langage C et principes de programmation.

------------ Voici quelques questions ------------

1-. Les opérateurs BIT à BIT. À quoi servent-t-ils? Je sais qu'ils servent à manipuler les nombres binaires, mais, ce que je veux savoir, c'est en quelles circonstances peuvent-ils être indispensables, ou du moins très pratiques. Quel rôles peuvent-ils jouer dans un programme?

2-. Voici un extrait d'un bouquin de C.

Conversion rules are more complicated when unsigned operands are involved. The problem
is that comparisons between signed and unsigned values are machine-dependent, because they
depend on the sizes of the various integer types. For example, suppose that int is 16 bits and
long is 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is promoted to a
signed long. But -1L > 1UL because -1L is promoted to unsigned long and thus appears
to be a large positive number.

Je ne comprends pas les affirmations que l'auteur donne dans ses exemples.
Comment -1L peut-être plus grand que 1UL, puisque -1L sera converti en UL lui auss.

3-. GMP est une librairie qui utilise des TAD pour faire des calculs. Si, par exemple, je déclare une variable nommée "var" du type "mpf_t", qui est le type des flottants de GMP, comment pourrais-je donner à "var" la valeur de 718.26341282353482? Sûrement pas en faisant "mpf_t var = 718.26341282353482"... Alors comment? Sûrement avec une fonction, mais comment on procède dans la fonction. Est-ce que l'on donne le nombre en chaîne de caractères, est-ce que l'on donne à la fonction les chiffres avant et après la virgule séparément?

----------------------------------------

Avant de programmer des TAD, j'aimerais éclaicir ma compréhension sur certains sujets. J'y reviendrai certainement prochainement.

[En fait, je veux faire une librarie qui utilise les flottants en précision arbitraire, avec les algorithmes les plus rapides, comme GMP. Ceci me permettra de m'améliorer significativement, et je pourrai disposer de mon code comme je veux, sans la license GNU LGPL (je n'ai rien contre, mais comme j'aime beaucoup les mathématiques et que je projette de travailler massivement sur les nombres flottants, j'aime mieux avoir une certaine liberté que je n'aurais peut-être pas avec GMP).]
C'est de l'arithmétique, donc, utilisation des divers algorithmes de simplification des calculs (Karatsuba, Tom Cook, FFT, ...).

Voilà.

Je vous remercie,

Sincèrement,

Array

**Thierry Chappuis** · 14/12/2007, 07h31

Envoyé par Array

[En fait, je veux faire une librarie qui utilise les flottants en précision arbitraire, avec les algorithmes les plus rapides, comme GMP. Ceci me permettra de m'améliorer significativement, et je pourrai disposer de mon code comme je veux, sans la license GNU LGPL (je n'ai rien contre, mais comme j'aime beaucoup les mathématiques et que je projette de travailler massivement sur les nombres flottants, j'aime mieux avoir une certaine liberté que je n'aurais peut-être pas avec GMP).]

Quelle liberté estimes-tu ne pas avoir avoir avec la license LGPL.

Thierry

**Array** · 14/12/2007, 20h08

Eh bien, en fait, peut-être cela peut vouss paraître idiot et inutile de ma part... Enfin bref, en fait la vérité est que j'aimerais faire une telle librairie moi-même parce que c'est une sorte de 'défi' pour moi...

Voilà.

**Emmanuel Delahaye** · 14/12/2007, 23h07

Envoyé par Array

Donc, j'en déduis que ce qui constitue une grade partie du TAB est l'interface.

TAB ? Tu veux dire TAD ? L'interface ? Un TAD a certes une interface, mais je ne vois pas ce que tu veux dire...

1-. Les opérateurs BIT à BIT. À quoi servent-t-ils? Je sais qu'ils servent à manipuler les nombres binaires, mis, ce que je veux savoir, c'est en quelles circonstances peuvent-ils être indispensables, ou du moins très pratiques. Quel rôles peuvent-ils jouer dans un programme?

Dans certains cas, les bits d'une donnée ont une sémantique bien particulière. Les opérateurs bits à bits permettent de déterminer l'état et de le modifier.

3-. GMP est une librairie qui utilise des TAD pour faire des calculs. Si, par exemple, je déclare une variable nommée "var" du type "mpf_t", qui est le type des flottants de GMP, comment pourrais-je donner à "var" la valeur de 718.26341282353482? Sûrement pas en faisant "mpf_t var = 718.26341282353482"... Alors comment? Sûrement avec une fonction, mais comment on procède dans la fonction. Est-ce que l'on donne le nombre en chaîne de caractères, est-ce que l'on donne à la fonction les chiffres avant et après la virgule séparément?

Aucune idée. Je suppose qu'il faut commencer par lire la doc...

**Thierry Chappuis** · 17/12/2007, 08h20

Envoyé par Emmanuel Delahaye

Sur une machine 16-bit, -1UL vaut FFFF. Sur une machine 32-bit, il vaut FFFFFFFF.

-1 UL est assuré d'être représenté au moins sur 32 bits (ULONG_MAX vaut au minimum 4294967295), même sur une machine 16 bits (du moment que le compilateur est conforme).

Dans l'expression -1L < 1UL, -1 est implicitement converti (promu) en unsigned int avant que la comparaison soit effectuée. On se retrouve donc dans la situation suivante: -1UL est représenté par 0xFFFFFFFF (ULONG_MAX) et 1UL est 0x1. Donc: -1UL > 1UL. Si tu utilises gcc avec l'option de compilation -Wconversion, tu obtiendras un avertissement.

Thierry

**Emmanuel Delahaye** · 17/12/2007, 15h12

Envoyé par Thierry Chappuis

-1 UL est assuré d'être représenté au moins sur 32 bits (ULONG_MAX vaut au minimum 4294967295), même sur une machine 16 bits (du moment que le compilateur est conforme).

Oups, oui, exact.

**Array** · 24/12/2007, 06h21

Bonjour,

Merci pour vos multiples réponses.

Dans l'expression -1L < 1UL, -1 est implicitement converti (promu) en unsigned int avant que la comparaison soit effectuée.

Dans le text que j'ai envoyé, l'auteur affirme que "-1L > 1UL", et non "-1L < 1UL".
!!? "-1" n'est-il pas supposé être converti en "signed long int"?
Pourquoi "unsigned int"?
Ce n'est pas toujours du plus petit type vers le plus grand?

Conversion rules are more complicated when unsigned operands are involved. The problem
is that comparisons between signed and unsigned values are machine-dependent, because they
depend on the sizes of the various integer types. For example, suppose that int is 16 bits and
long is 32 bits. Then -1L < 1U, because 1U, which is an unsigned int, is promoted to a
signed long. But -1L > 1UL because -1L is promoted to unsigned long and thus appears
to be a large positive number.

Mais tout cela, n'est-ce pas valable seulement si l'on ne tient pas compte de la représentation des nombres négatifs, c'est-à-dire lorsqu'on lit le binaire sans rien soustraire?

Gah, j'ai de la difficulté à saisir.

Quelques explications supplémentaire seraient les bienvenues.

Merci,

Joyeux Noël,

Array

**Array** · 30/12/2007, 21h12

En outre,
Je désire savoir s'il est possible d'utiliser un argv à une dimension.
En général, on utilise deux dimensions pour argv, mais qu'advient-il si la déclarations de main est celle-ci :

Code :

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

int main(int argv, char *argv);

Merci,

Array

**Médinoc** · 30/12/2007, 21h17

En ce cas, argv ne voudra pas dire grand-chose.
Ce sera comme un tableau de pointeurs castés en char*. Il me semble que ça ne plantera pas car si je me souviens bien, la norme garantit que le dernier pointeur est nul, mais un puts(argv) n'affichera que du gobbledygook...

**Emmanuel Delahaye** · 30/12/2007, 22h19

Envoyé par Array

Je désire savoir s'il est possible d'utiliser un argv à une dimension.
En général, on utilise deux dimensions pour argv, mais qu'advient-il si la déclarations de main est celle-ci :

Code :

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

int main(int argc, char *argv);

Comportement indéfini.

Il n'y a pas le choix. C'est l'adresse du premier élément d'un tableau de pointeurs sur char présent en mémoire statique d'où un type char **. C'est la Loi. Pourquoi voudrais-tu changer ça ? C'est pas toi qui décide de ce qui est pointé par ce pointeur. Le comportement des paramètres est spécifié, il faut s'y conformer, point.

**Array** · 02/01/2008, 04h26

Salutations,

J'aurais deux questions, puisque la précédente a été répondue avec succès.

--------------------------
1-. J'ai un programme qui lit un fichier pour exécuter des tâches.
En fait, c'est un fichier de configurations utilisé pour CRÉER des variables (comme le "INT var =" en C, le "set VAR=" en DOS BATCH, le "VAR=" en SH, etc .) locales au programme.

Voici une config en aperçu (le caractère de commentaire étant le #) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
################################################
############## PRINCIPAL SETTINGS ##############
################################################
 
FILEKEY = keylist.cfg
USER_0 = Lincoln
USER_1 = Kennedy
NUMBER_X = 82
NUMBER_Y = 139
NUMBER_Z = 226
INTERVAL = 927
 
#[...]

Alors, je voudrais savoir comment pouvoir faire cette opérations, c'est à dire allouer de la mémoire afin de créer des variables qui, elles, seront utilisées à des fins diverses.

Si possible, je voudrais ne pas utiliser l'environnement, ne pas toucher aux fonctions telles que getenv();

2) Sur Winblows seulement :
Vous savez, il y a en batch une commnde appelée "echo".
Si l'on fait "@ECHO OFF", on ne verra plus le "PROMPT".
Soit un code quelconque :

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) {
	system("@echo off");
	system("echo Press any key to continue.");
	system("pause>nul");
	system("for /L %i in (0,+1,5) do echo %i");
	return 0;
}

Ledit programme, une fois compilé avec GCC puis exécuté de façon adéquate, écrit cela dans la console Windows :

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
 
Press any key to continue.
 
C:\Documents and Settings\Lincoln\Bureau>echo 0 
0
 
C:\Documents and Settings\Lincoln\Bureau>echo 1 
1
 
C:\Documents and Settings\Lincoln\Bureau>echo 2 
2
 
C:\Documents and Settings\Lincoln\Bureau>echo 3 
3
 
C:\Documents and Settings\Lincoln\Bureau>echo 4 
4
 
C:\Documents and Settings\Lincoln\Bureau>echo 5 
5

Alors qu'il serait censé donner cela :

Code :

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

1
2
3
4
5
6
7
8
 
Press any key to continue.
0
1
2
3
4
5

Pourquoi "@echo off" ne fonctionne pas adéquatement comme dans un script batch? Comment remédier à ce problème?

----------------------------

Chers distingués développeurs,

Merci d'avance pour vos réponses,

Respectueusement,

Array

**totaliou** · 02/01/2008, 05h04

Pourquoi ne pas ouvrir une nouvelle discussion ?
La question n'a pas de lien avec le poste d'origine? Si oui désolé mais il y a plus de 170 messages et c'est difficile de suivre le fil.

**Array** · 02/01/2008, 06h45

J'ai trop de questions diversifiées pour initier un topic à CHAQUE questions. À moins que je me trompe...

Quelques précisions. . .

C

Discussions similaires

Partager

Partager