Question sur un code

Version imprimable

16/01/2010, 14h31
deubelte

Question sur un code
Bonjour

J'ai deux questions sur le code suivant, issu d'un programme que j'étudie
Code:

1 2 3 #ifdef __WXMSW__ #define isnan(x) (_isnan(x)) #endif
A quoi correspond WXMSW? Je suppose que c'est un compilateur, comme Visual C++?

Je ne comprends pas non plus la structure du code:
#define isnan(x) (_isnan(x))

Pour moi, la fonction isnan existe dejà, et on la redéfinit. Mais quel est l'intérêt? Pourquoi le mettre en paranthèse?
Merci
16/01/2010, 14h51
jabbounet
Code:

1 2 3 4 5 6 #ifdef __WXMSW__ code1 #else code2 #endif
Cela se passe lors de la compilation, #ifdef Vérifie si le symbole est définit.

Si dans le code précédent cette ligne ou dans un include placé aussi avant ce symbole est défini alors alors code1 est compilé sinon cela compile code2
Code:

1 2 #define isnan(x) (_isnan(x))
Défini une macro isnan paramétré dont le parametre est x

lors de la compilation si dans ton code tu utilise cette macro elle sera remplacé par le contenu de la macro.

quelques infos ici
http://www.cplusplus.com/doc/tutorial/preprocessor/
[ame]http://en.wikipedia.org/wiki/C_preprocessor[/ame]

Cordialement

J'ai encore une question mais sur la structure suivante, dont j'ai besoin de comprendre le code et le fonctionnement de celui-ci.
Code:

1 2 3 4 5 6 typedef struct buffer_ { long *buffer; long *start,*end; long size; char flagEof; /* Set if an end of file character has been pulled (then the buffer will freeze) */ } Buffer, *BUFFER;
On définit ici un nouvel objet, "buffer", qui est en réalité une sorte de "tableau" contenant des "long", puisqu'on a : long *buffer.
Ma question est: a quoi sert le mot: buffer_? Pourquoi ne pas faire simplement:
Code:

1 2 3 typedef struct Buffer { ..... } Buffer, *BUFFER;
A la fin, on a Buffer et *BUFFER.
Cela nous permet plus tard de définir un objet de type Buffer, et un autre objet, qui est cette fois un pointeur sur Buffer.

On a ensuite la fonction d'allocation:
Code:

1 2 3 4 5 6 7 8 9 10 11 BUFFER NewBuffer(int size) { BUFFER buf; buf = (BUFFER) Malloc(sizeof(struct buffer_)); buf->buffer = Malloc(sizeof(long)*(size+1)); buf->size = size+1; buf->start = buf->end = buf->buffer; buf->flagEof = '\n'; return(buf); }
Cette fonction renvoie un objet de type BUFFER, qui est un pointeur sur Buffer
la première allocation est fictive, elle permet de créer l'objet buf,
et la deuxième est réelle, car elle permet de définir la taille de l'objet buf?
(j'ai l'impression qu'on fait deux fois la même chose). C'est du C, qu'est ce que cela donnerait en C++?
Merci

16/01/2010, 18h52
jabbounet

tu aura des explications ici sur typedef et les structures
http://fr.wikibooks.org/wiki/Program...s_avanc%C3%A9s

il y'a aussi une section tutoriel sur le site
http://melem.developpez.com/tutoriel...page=struct#LV

Bonjour,
Citation:
Envoyé par deubelte
Code:

1 2 3 #ifdef __WXMSW__ #define isnan(x) (_isnan(x)) #endif
A quoi correspond WXMSW? Je suppose que c'est un compilateur, comme Visual C++?
__WXMSW__ est une directive de compilation utilisée par wxWidgets pour distinguer le code généré pour la plateforme Windows du code généré pour d'autres plateforme. Cette directive n'est définie que lorsque le code est compilée pour produire un logiciel exécutable avec Windows. Par conséquent, tout ce qui se trouve entre ifdef __WXMSW__ et endif ne sera défini que dans ce cas.

Citation:

Envoyé par deubelte

Je ne comprends pas non plus la structure du code:
#define isnan(x) (_isnan(x))

Pour moi, la fonction isnan existe dejà, et on la redéfinit. Mais quel est l'intérêt? Pourquoi le mettre en paranthèse?
Merci

isnan est une fonction C du standard de 99. Cette fonction ne s'appelle pas comme ça sur le compilateur Visual, mais _isnan - avec un caractère souligné en début. isnan et _isnan sont par défaut considérés comme 2 symboles différents par le compilateur. Afin d'utiliser toujours dans son code la même écriture (isnan sans souligné) l'auteur du code utilise la directive de compilation pour faire correspondre la macro isnan vers la fonction _isnan pour les compilations avec windows.
Citation:
Envoyé par deubelte
J'ai encore une question mais sur la structure suivante, dont j'ai besoin de comprendre le code et le fonctionnement de celui-ci.
Code:

1 2 3 4 5 6 typedef struct buffer_ { long *buffer; long *start,*end; long size; char flagEof; /* Set if an end of file character has been pulled (then the buffer will freeze) */ } Buffer, *BUFFER;
On définit ici un nouvel objet, "buffer", qui est en réalité une sorte de "tableau" contenant des "long", puisqu'on a : long *buffer.
Ma question est: a quoi sert le mot: buffer_? Pourquoi ne pas faire simplement:
Code:

1 2 3 typedef struct Buffer { ..... } Buffer, *BUFFER;
En C, lorsque tu déclares une structure struct toto, pour l'utiliser tu dois toujours faire précéder le nom toto par le mot clé struct :
Code:

1 2 3 4 5 struct toto{ /* définition de la structure */ }; struct toto ma_variable; /* OK */ toto ma_variable; /* Erreur */
D'où le typedef qui permet de définir un symbole équivalent. On peut alors utiliser Buffer sans le faire précéder de struct.
Citation:
Envoyé par deubelte
A la fin, on a Buffer et *BUFFER.
Cela nous permet plus tard de définir un objet de type Buffer, et un autre objet, qui est cette fois un pointeur sur Buffer.

On a ensuite la fonction d'allocation:
Code:

1 2 3 4 5 6 7 8 9 10 11 BUFFER NewBuffer(int size) { BUFFER buf; buf = (BUFFER) Malloc(sizeof(struct buffer_)); buf->buffer = Malloc(sizeof(long)*(size+1)); buf->size = size+1; buf->start = buf->end = buf->buffer; buf->flagEof = '\n'; return(buf); }
Cette fonction renvoie un objet de type BUFFER, qui est un pointeur sur Buffer
la première allocation est fictive, elle permet de créer l'objet buf,
et la deuxième est réelle, car elle permet de définir la taille de l'objet buf?
(j'ai l'impression qu'on fait deux fois la même chose).
La première allocation n'est pas fictive. Il y a deux choses : la première allocation permet d'obtenir une zone mémoire qui pourra contenir les membres de la structure :
-> long *buffer : un pointeur sur un long ;
-> long *start : un pointeur sur un long ;
-> long *end : un pointeur sur un long ;
-> long size : un long ;
-> char flagEof : un char.
buf contient alors l'adresse de cette zone mémoire.
La seconde allocation réserve une zone mémoire pouvant contenir size éléments de type long. L'adresse de cette nouvelle zone est mise dans le premier pointeur de buf, buf->buffer et la taille dans buf->size;
On a donc bien deux allocations différentes, deux zones mémoires différentes et deux rôles différents.
Je pense que le fait que la structure et qu'un de ses membres possèdent le même nom créé la confusion dans la compréhension de ce code. Il vaudrait mieux changer le nom de l'un des deux pour plus de clarté.

Citation:

Envoyé par deubelte

C'est du C, qu'est ce que cela donnerait en C++?

Il est toujours difficile de traduire du C en C++ car la conception serait probablement différente. Mais, disons, que les différences notables seraient :
-> L'utilisation d'un std::vector pour le tableau ;
-> new/delete pour les allocations et les libérations ;
-> l'utilisation d'un pointeur intelligent pour retourner le nouvel objet.
-> détail syntaxique : en C++, le typedef n'est pas utile (sauf pour le pointeur, bien sûr).
Cela ferait :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 struct s_buffer { std::vector<long> buffer; //long *start,*end; -> dépend de ce que c'est effectivement représenté. Peut être que ce serait une fonction de la structure buffer. //long size; -> pas besoind existe déjà dans std::vector char flagEof; }; typedef boost::shared_ptr<s_buffer> sp_buffer; sp_buffer NewBuffer(int size) { sp_buffer new_buf(new s_buffer); new_buf->buffer.resize(size+1); new_buf->flagEof = '\n'; return(new_buf); }
Mais comme je te l'ai dit, le code ne serait probablement pas transposé tel quel. Ce serait probablement une erreur. Le passage par l'objet bénéficierait d'une nouvelle conception avec les notions de l'objet.

16/01/2010, 21h09
deubelte

Merci pour la réponse
(Un pti messge de remerciement s'imposait, vue la réponse donnée par Archi3d)

En C++, ça donnerait pas plutôt ça?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
class Buffer
{
public:
 
    // Constructeur
    Buffer( int size )
    : m_flagEof( "\n" )
    {
        this->m_buffer.resize(size+1); 
    }
 
private:
 
    std::vector<long> m_buffer;
    char m_flagEof;
};
 
int main()
{
    Buffer buffer( 5 );
 
    return 0;
}

Enfin dans le cas où on utilise effectivement un std::vector< long > pour un "buffer"

17/01/2010, 19h15
3DArchi
Citation:

Envoyé par nikko34

En C++, ça donnerait pas plutôt ça?

Ca pourrait. L'encapsulation pourrait avoir un sens ou pas. C'est pour ça que j'ai voulu insister sur le fait qu'on ne transcrit que rarement des structures C vers des classes si on souhaite porter un projet de C vers C++. Le portage vers C++ nécessite de re-concevoir l'application pour tirer bénéfice de façon optimale de ce que peut apporter l'objet (encapsulation, abstraction, généricité, etc.).
De façon plus anecdotique, en voyant ses pointeurs begin/end, je me demande si en C++, ça ne se traduirait pas tout simplement comme ça :
Code:

1 2 typedef boost::circular_buffer<long> Buffer;
:mouarf: