Discussion :

[@r$£~%[]

Bonjours,

Je voudrait savoir comment créer une fonction avec un groupe de flags, comme SDL_Init( SDL_INIT_VIDEO | SDL_INIT_AUDIO)

[khayyam90]

tu peux prendre exemple sur les flags de la SDL :

[...]
#define SDL_INIT_TIMER 0x00000001
#define SDL_INIT_AUDIO 0x00000010
#define SDL_INIT_VIDEO 0x00000020
#define SDL_INIT_CDROM 0x00000100
#define SDL_INIT_JOYSTICK 0x00000200
[...]

Si en plus tu sais que l'oprateur bit à bit | réalise un ou inclusif logique, tu as toutes les cartes en main pour réaliser une fonction avec des flags.

Dans ton exemple, la fonction SDL_Init ne prend qu'un argument, qu'il suffit d'analyser pour retrouver tous les flags positionnés. Le tout étant que les valeurs définies pour chaque flag ne puissent jamais se recouper

[@r$£~%[]

Qu' est ce qu' exactement un ou inclusif logique?

Est-ce qu' au finale, j' aurais une addition des nombres?

Edit : non, ça va, j' ai compris.

Pour çeux qui voudrait le savoir :

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
 
#define FLAG1 100
#define FLAG2 010
#define FLAG3 001
 
void fonction_avec_flags(int flag)
{
     if(flag == 110)
     {
          //Les flags : 1 et 2
     }
     else if(flag == 010)
     {
          //Les flags : 2
     }
     else if(flag == 111)
     {
          //Les flags : 1, 2 et 3
     }
}

[diogene]

Qu' est ce qu' exactement un ou inclusif logique

L'opération OU logique (inclusif) correspond à (a et b étant deux bits)

a|b == 1 si a == 1 ou si b == 1 ou si les deux valent 1 (inclusif)

ce qui revient à dire

a|b == 0 si a == 0 et si b == 0

En repartant de l'exemple :

Code :

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

1
2
3
4
5
#define SDL_INIT_TIMER 0x00000001 
#define SDL_INIT_AUDIO 0x00000010 
#define SDL_INIT_VIDEO 0x00000020
......
SDL_INIT_AUDIO | SDL_INIT_VIDEO == 0x00000030

Est-ce qu' au finale, j' aurais une addition des nombres?

Ceci est différent d'une addition. Exemple :

Code :

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

0x7 |0x3 == 0x7

[Caine]

Dans ton exemple c'est un OU binaire.

0x01 | 0x02 -> 0x03 OU Binaire.

0x01 || 0x02 -> 0x01 OU Logique

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <stdlib.h>
#include <iostream.h>
 
int main() {
char Pause;
 
cout << "OU logique : "<< 0x01 << " || " << 0x02 << " vaut "<< (0x01 || 0x02)<<endl;
 
cout << "OU binaire : "<< 0x01 << " | " << 0x02 << " vaut "<< (0x01 | 0x02)<<endl;
 
cin >> Pause;
return EXIT_SUCCESS;	
}

Et pour mélanger des flags, c'est bien le OU binaire qu'il faut utiliser.
Ainsi que le ET binaire.

[@r$£~%[]

Merci à toi,

mais à quoi sert le & exactement?

[khayyam90]

mais à quoi sert le & exactement?

lorsqu'il est placé entre 2 valeurs, c'est l'opérateur bit à bit ET (le ET binaire dont parle Caine)
et lorsqu'il est placé devant une variable, c'est l'opérateur d'adressage (qui retourne l'adresse mémoire de la variable)

[diogene]

Caine a écrit

0x01 || 0x02 -> 0x01 OU Logique

Dans le cas du OU (||) ce résultat n'est pas évident. Il s'agit de manipuler des grandeurs booléennes true/false.
Certes, false est en général représenté en machine par 0 et true par != false. L'utilisateur n'a pas à savoir comment est représenté true (c'est une question d'abstraction des données) ni d'ailleurs false. l'opérateur || doit être utilisé avec des opérandes à type booléens, dont les valeurs sont true ou false, et fournit une réponse booléenne.
Ta proposition doit s'énoncer true || true == true. Pas plus
[Edit]
khayyam90 peut également ajouter à la liste des utilisations de & les références.
[/Edit]

[@r$£~%[]

Et à quoi sert l' operateur ET bit à bit?

[Bob.Killer]

c une comparaison pour voir si les bits que tu veux vérifier sont allumé ou éteind.

ex :

chiffre que tu veux vérifier : 0x25 (00100101)
masque pour voir si le dernier bit est allumé : 0x01 (00000001)

tu fais un ET bit à bit :

Code :

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

if (0x25 & 0x01)

-> condition = true car le bit cherché est allumé dans le chiffre

[Caine]

Je suis d'accord, mais tu parlais bien du résultat d'un OU binaire, seul cas qui garanti que 0x01 OU Binaire 0x02 == 0x03.

Le résultat avec un OU Logique ne garanti pas d'obtenir 0x03.

En d'autre terme, je dirais que :

(A | B ) != (A || B)

Sauf implémentation spécifique à un compilateur ou en raison des valeurs de A et B.

Caine a écrit

0x01 || 0x02 -> 0x01 OU Logique

Dans le cas du OU (||) ce résultat n'est pas évident. Il s'agit de manipuler des grandeurs booléennes true/false.
Certes, false est en général représenté en machine par 0 et true par != false. L'utilisateur n'a pas à savoir comment est représenté true (c'est une question d'abstraction des données) ni d'ailleurs false. l'opérateur || doit être utilisé avec des opérandes à type booléens, dont les valeurs sont true ou false, et fournit une réponse booléenne.
Ta proposition doit s'énoncer true || true == true. Pas plus
[Edit]
khayyam90 peut également ajouter à la liste des utilisations de & les références.
[/Edit]