Hello !

Il n'est pas rare de constater que sur certains sujets de discussion, on est parfois obligé (ou d'autres gens le sont) de linker des articles listant les différents opérateurs du C++ avec diverses informations à coté. Mais il suffit d'aller faire une recherche sur le net pour constater que certains sites ne vous parlent que de priorité et d'associativité alors que d'autres n'en parlent pas et structurent seulement le tout en catégories (opérateurs de comparaison, bitwise, etc.).

Je propose donc un petit topic présentant les opérateurs du C++ en faisant un peu la somme des sites intéressants que j'ai croisés et en ajoutant une petite touche personnelle. Ce topic se veut donc être une "liste" des opérateurs du C++ directement sur le SdZ mais aussi une source d'informations sur ces derniers.

Je présente ça sous la forme d'un grand tableau, listant les différents opérateurs avec les informations suivantes pour chaque : catégorie (logique, bitwise, comparaison, etc.), nom (dénomination), syntaxe, exemple, priorité (de 0 à 16), associativité (Left-to-Right (LR) ou Right-to-Left (RL)), surchargeable ou non et présent dans le langage C ou non. Si vous sentez que quelque chose manque, n'hésitez pas à poster (ici-même) pour me le faire savoir et on pourra en discuter.

Catégorie	Nom	Syntaxe	Exemple	Priorité	Associativité	Surchargeable ?	Présent dans le C ?	Prototype pour surcharge
Opérateurs arithmétiques	Plus unaire	+x	rule<> r = +ch_p('a'); // cf boost::spirit	14	RL	Oui	Oui	<T>& <T>::operator+() const;
Addition	x + y	int i = 1+1; //2	11	LR	Oui	Oui	<T> operator+(<T> const& a, <S> const& b)
Incrémentation préfixée	++x	for(; i<s; ++i)	14	RL	Oui	Oui	<T>& <T>::operator++()
Incrémentation postfixée	x++	s[i++] = 'a';	15	LR	Oui	Oui	<T> <T>::operator++(int bidon)
Assignment by addition	x += y	string s; s += "hello";	1	RL	Oui	Oui	<T>& <T>::operator+=(<S> const& other)
Moins unaire	-x	return -1;	14	RL	Oui	Oui	<T> <T>::operator-() const
Soustraction	x - y	int i = 5-3; //2	11	LR	Oui	Oui	<T> operator-(<T> const& a, <S> const& b)
Décrémentation préfixée	--x	for(; i>0; --i)	14	RL	Oui	Oui	<T>& <T>::operator--()
Décrémentation postfixée	x--	s[i--] = 'b';	15	LR	Oui	Oui	<T> <T>::operator--(int bidon)
Assignment by substraction	x -= y	int i = 5; i -= 2; //3	1	RL	Oui	Oui	<T>& <T>::operator-=(<S> const& other)
Multiplication	x * y	int i = 2*3; //6	12	LR	Oui	Oui	<T> operator*(<T> const& a, <S> const& b)
Assignment by multiplication	x *= y	int i = 2; i *= 3; //6	1	RL	Oui	Oui	<T>& <T>::operator*=(<S> const& other)
Division	x / y	int i = 4/2; //2	12	LR	Oui	Oui	<T> operator/(<T> const& a, <S> const& b)
Assignment by division	x /= y	int i = 10; i /= 5; //2	1	RL	Oui	Oui	<T>& <T>::operator/=(<S> const& other)
Modulo	x % y	pgcd(b, a%b);	12	LR	Oui	Oui	<T> operator%(<T> const& a, <S> const& b)
Assignment by modulus	x %= y	int i = 10; i %= 4; //2	1	RL	Oui	Oui	<T>& <T>::operator%=(<S> const& other)
Opérateurs de comparaison	Inférieur à	x < y	if(4 < 5) //true	9	LR	Oui	Oui	bool operator<(<T> const& a, <S> const& b)
Inférieur ou égal à	x <= y	if(4 <= 4) //true	9	LR	Oui	Oui	bool operator<=(<T> const& a, <S> const& b)
Supérieur à	x > y	bool b = 2>2; //false	9	LR	Oui	Oui	bool operator>(<T> const& a, <S> const& b)
Supérieur ou égal à	x >= y	bool b = 2>=2; //true	9	LR	Oui	Oui	bool operator>=(<T> const& a, <S> const& b)
Différent de	x != y	while(*s != '\0')	8	LR	Oui	Oui	bool operator!=(<T> const& a, <S> const& b)
Égal à	x == y	if(5 == 2+3) //true	8	LR	Oui	Oui	bool operator==(<T> const& a, <S> const& b)
Opérateurs logiques	Non	!x	bool b = true; if(!b) //false	14	RL	Oui	Oui	bool <T>::operator!() const
Et	x && y	bool b = true; if(b && 1>0) //true	4	LR	Oui	Oui	bool operator&&(<T> const& a, <S> const& b)
Ou	x || y	if(true || false) //true	3	LR	Oui	Oui	bool operator||(<T> const& a, <S> const& b)
Opérateurs bit à bit	Décalage à gauche	x << y	int i = 6<<1; //12	10	LR	Oui	Oui	<T> operator<<(<T> const& a, <S> const& b)
Assignment by bitwise left shift	x <<= y	int i = 4; i <<= 1; //8	1	RL	Oui	Oui	<T>& <T>::operator<<=(<S> const& other)
Décalage à droite avec conservation du signe	x >> y	int i = 18>>1; //9	10	LR	Oui	Oui	<T> operator>>(<T> const& a, <S> const& b)
Assignment by bitwise right shift	x >>= y	int i = 20; i >>= 1; //10	1	RL	Oui	Oui	<T>& <T>::operator>>=(<S> const& other)
"Non" bit à bit	~x	int i = ~5; //-6	14	RL	Oui	Oui	<T> <T>::operator~() const
"Et" bit à bit	x & y	int i = 7 & 12; //4	7	LR	Oui	Oui	<T> operator&(<T> const& a, <S> const& b)
Assignment by bitwise "AND"	x &= y	int i = 7; i &= 12; //4	1	RL	Oui	Oui	<T>& <T>::operator&=(<S> const& other)
"Ou" bit à bit	x | y	int i = 7 | 12; //15	5	LR	Oui	Oui	<T> operator|(<T> const& a, <S> const& b)
Assignment by bitwise "OR"	x |= y	int i = 7; i |= 12; //15	1	RL	Oui	Oui	<T>& <T>::operator|=(<S> const& other)
"Ou" exclusif bit à bit	x ^ y	int i = 7 ^ 12; //11	6	LR	Oui	Oui	<T> operator^(<T> const& a, <S> const& b)
Assignment by bitwise "XOR"	x ^= y	int i = 7; i ^= 12; //11	1	RL	Oui	Oui	<T>& <T>::operator^=(<S> const& other)
Autres opérateurs	Affectation	x = y	float f = 4.2;	1	RL	Oui	Oui	<T>& <T>::operator=(<S> const& other)
Appel de fonction	x()	printf("foo");	15	LR	Oui	Oui	<R>& <T>::operator()(...)
Indice de tableau	x[]	string s("foo"); char c = s[0]; //f	15	LR	Oui	Oui	<R>& <T>::operator[](<S> const& index)
Déréférencement	*x	const char* s("foo"); cout << *s; //f	14	RL	Oui	Oui	<R>& <T>::operator*()
Adresse de	&x	int i; int* p = &i;	14	RL	Oui	Oui	<T>* <T>::operator&()
Déréférencement + adressage	x->y	ptr_vector->at(0);	15	LR	Oui	Oui	<R> <T>::operator->()
Adressage	x.y	m_vector.at(0);	15	LR	Non	Oui	Impossible
Déréférencement + adressage d'un pointeur sur membre	x->*y	/	13	LR	Oui	Non	<R>& <T>::operator->*()
Adressage d'un pointeur sur membre	x.*y	/	13	LR	Non	Non	impossible
Conversion de type	(type)x	int i = (int)4.5;	14	RL	Oui	Oui	<T>::operator <R>()
Opérateur virgule (succession)	x, y	for(;; i++, j++)	0	LR	Oui	Oui	<S>& operator,(<T> const& obj, <S>& other)
Selon que	x ? y : z	int i = (1<2) ? 42 : 50; //42	2	RL	Non	Oui	impossible
Résolution de portée	x::y	std::string s;	16	LR	Non	Non	impossible
Résolution de portée pour les pointeurs sur membre	x::*y	/	1	LR	Non	Non	impossible
Taille de	sizeof x	int i = sizeof(char); //1	14	RL	Non	Oui	impossible
Identification de type	typeid(x)	cout << typeid(int).name(); //i	15	LR	Non	Non	impossible
Allocation	new type	bool* b = new bool;	14	RL	Oui	Non	void* operator new(size_t size, ...)
Allocation de tableau	new type[n]	int* a = new int[10];	14	RL	Oui	Non	void* operator new[](size_t size, ...)
Désallocation	delete x	int* i = new int; delete i;	14	RL	Oui	Non	void operator delete(void* toDelete)
Désallocation de tableau	delete[] x	int* i = new int[10]; delete[] i;	14	RL	Oui	Non	void operator delete[](void* toDelete)

Il est possible qu'il y ait dans ce tableau quelques erreurs d'inattention, aussi si vous en voyez, faites moi signe. Mes sources sont diverses, la catégorisation et l'ordre d'énumération des différents opérateurs est celui de l'article wikipédia à ce sujet et certaines traductions de dénominations anglaise proviennent quant à eux de ce site. Les informations sur la priorité et l'associativité viennent d'un peu partout. Les exemples sont tout droit sortis de ma tête.

Un dernier point concernant ces traductions : il y a quelques opérateurs dont je n'ai pas traduit la dénomination parce que je ne trouvais rien de convenable : ces noms sont en italique. Si vous avez des propositions ou si vous trouvez certaines traductions maladroites, faites-le moi savoir.

Il reste les exemples : certains ne sont peut-être pas adaptés ou pas assez parlants, si vous avez mieux à proposer (mais bon, c'est pas super important non plus), bah ... proposez. Tout autre remarque est la bienvenue également.

Cordialement,

shareman

-
Edité par shareman 30 septembre 2013 à 16:18:54

C'est normal. La norme ne parle pas explicitement de priorité. Elles se déduisent de la grammaire.

Sinon,
b- s/rotation/décalage # la rotation ne perd aucun bit

c- il manque l'opérateur virgule (arf, on dira "opérateur virgule" et pas succession histoire de coller à la VO -- c'est tellement plus simple pour s'y retrouver dans la doc)

d- s/assignation/affectation

e- pour être exhaustif, il faudrait évoquer les ordres d'évaluation au sujet desquels il n'existe aucune garantie hormis les cas des opérateurs logiques ET et OU fournis sur les types primitifs (on repart sur fonction normale et donc l'absence de point de séquencement si on venait à les surcharger pour nos propres types).

f- cela vaudrait presque le coup de donner les règles canoniques de surcharge -- ce n'est pas le cas de celles du tuto.

Sur la conversion de type: shame on you , tu présentes les cast C-like; Tu pourrais au moins parler des casts C++ même si je ne suis pas sûr à 100% qu'ils rentrent dans la catégorie "opérateurs".

Sinon, c'est bien beau de donner une liste quasi brut, mais donner les remarques classiques qui vont avec, c'est mieux.

( Ne devrait-ce pas être dans les mots-clefs ? http://www.siteduzero.com/forum-83-175 [...] html#r1949003 )

Il pourrait y avoir la façon de le surcharger à côté de Syntaxe...
Exemple :

T& Classe::operator+=(const T& nombre)

Certains exemples sont un peu brutaux quand même. Sortir boost::spirit ici... et les trucs genre a[i--] = 2; c'est pas vraiment du code clair non-plus...

Tu pourrais donner la source...
http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B

Sinon, il serait bien d'expliquer les règles de prioritéparce que là, les chiffres seuls ça veut rien dire. De même que l'associativité.

Citation : Nanoc

Sinon, il serait bien d'expliquer les règles de prioritéparce que là, les chiffres seuls ça veut rien dire. De même que l'associativité.

+1, j'aimerais bien savoir ce que ça signifie.

Les chiffres veulent tout dire. Plus un nombre est grand, plus grande est la priorité de son opérateur (donc il passe avant les opérations moins prioritaires). On peut donc évaluer la priorité de chaque opérateur par rapport aux autres. Je ne vois pas quel est votre problème avec les chiffres là, Nanoc et companie.

Et c'est quoi le problème avec l'associativité ? LR : Left to Right, RL : l'inverse. Faut traduire "left" et "right" ?

Hum ... Je maintiens mes commentaires que je vois non pris en compte.

Citation : shareman

Et c'est quoi le problème avec l'associativité ? LR : Left to Right, RL : l'inverse. Faut traduire "left" et "right" ?

Oui c'est clair que "LR" == "left to right". Mais ça veut dire quoi ? Pour un débutant c'est pas clair.

L'opérateur unpack aussi ? "..." pour les variadic templates.

Bonjour
j'espère que je poste sur le bon endroit
voila mon problème en bref : j'ai crée une classe "Complexe" qui gèrent les nombres complexes (en mathématiques) j'ai définit l'addition "operator+" et j'ai surchargé le flux de sortie "operator<<" tout ce passe bien quand j'effectue //a+b// ou //cout<<a<<b;// mais le problème c'est quand je mélange les deux opérateur genre //cout<<"la somme est : "<<a+b<<endl;// ou même si je met les parenthèse //cout<<(a+b)<<endl;// s'il vous plait comment je peux remédier a ce problème et si ça peut vous aider voila l'erreur que j'obtien sur DEV-C++
//")) << (&a)->Complexe::operator+(((const Complexe&)((const Complexe*)(&b))))' "//

Il faut créer un nouveau sujet, ensuite il faut ton code même si j'ai une petite idée de l'erreur

Pour sizeof, il y a deux syntaxes : sizeof expression, et sizeof(type).
Pour l'opérateur ternaire, j'éviterais les parenthèses inutiles dans l'exemple : int i = 1<2 ? 42 : 50;

Je crois bien qu'il en manque un : l'opérateur vide, qui peut être sympa à utiliser

Ici le code dans le cas le plus courant :

T::operator bool(void);

Il retourne un bool lorsqu'on l'appelle.

class Shader
{
    // ...
    operator bool(void) const { return is_enable(); }
};

Shader shader;

if (shader) // shader enabled
// ...

Il faut quand même faire gaffe avec ce genre d'opérateur !

EDIT : En fait, il retourne ce que vous voulez, le bool c'est dans mon exemple hein ...

Citation : -Skypers-

Je crois bien qu'il en manque un : l'opérateur vide, qui peut être sympa à utiliser

Ici le code dans le cas le plus courant :

T::operator bool(void);

Il retourne un bool lorsqu'on l'appelle.

class Shader
{
    // ...
    operator bool(void) const { return is_enable(); }
};

Shader shader;

if (shader) // shader enabled
// ...

Il faut quand même faire gaffe avec ce genre d'opérateur !

EDIT : En fait, il retourne ce que vous voulez, le bool c'est dans mon exemple hein ...

Oui, tu viens juste de définir un opérateur de conversion implicite ....

Euh ...g cherche pluto des metohdes deprogrammation

T chairch d metod d program ? g pe ten doné pl1 si t ve, tu é sr le bn topic tqvu

Pour les traductions de "assignment by ..." je proposerais comme traduction "affectation par ..." même si je pense que tout le mond comprend la version anglaise, je pense que ça pourrait ce traduire ainsi^^

Pour ce qui est de l'associativité, voilà ce que j'ai compris de l'article Wikipedia.

L'associativité des opérateurs est utilisée quand on est dans la situation où une opérande est entourée de deux opérateurs de même priorité en l'absence de parenthèses...
Imaginons l'affectation suivante : a = 7 - 4 + 2. Quelle sera la valeur de a ? Sera-ce 5 (= (7 - 4) + 2) ou 1 (= 7 - (4 + 2)) ?
C'est là que l'associativité est importante. "Associativité de gauche à droite" signifie que l'opérateur de gauche d'abord effectué. Donc, dans notre exemple, a vaudra 5...

myrddin, ton exemple est un peu pourris, les deux valent 5, l' addition et la soustraction ont la meme prioritées de meme que multiplication et division ;), j' avoue je savais pas quoi dire ...

j' avoue egalement que c' etait rien que pour t' embeter car tu as raison dans le fond mais bon

Ben zustement ! L'associativité ne sert qu'avec les opérateurs de même priorité ;0p nananereuh !

une petite rectification serait la bienvenue

postfixée => suffixé

Non, on dit postfixée.

Préfixe et suffixe

Les opérateurs d'incrémentation et de décrémentation existent en deux versions: préfixe et suffixe. Un préfixe précède le nom(++nom), alors que le suffixe le suit(nom++).

Merci

FaQ Devellopez.com
Utilise postfixé, et si tu cherches ailleurs on va trouver suffixe, je suppose que les deux sont valides.

désolé de vous décevoir mais la définition exacte est bien (suffixe et préfixe).
Le problème du net, c'est bien ce genre d'informations.

Il n'y a pas de référence officiel sur le C++ en francais ... donc ta source sera pas plus fiable qu'une autre.

Citation : Norme C++

The user-defined function called operator++ implements the prefix and postfix ++ operator.

Le problèlme c'est que postfix c'est pas dans le dictionnaire anglais (pas le mien en tout cas), et que suffixe en anglais se dit suffix, donc comment tu traduis un barbarisme ? On appel un docteur en lettre ? EMC1 a donné l'origine du terme.

Et franchement, version postfixée ou version suffixée, je pense que tout le monde comprend.

Edit: @EMC1: J'avais jamais remarqué que c'était le terme mathématique, pas fait le rapporchement

Ce n'est pas une question de C++, c'est un terme mathématique.

très bien donc,que faisons nous des suffixes et préfixes arithmétique.

EN TERME MATHÉMATIQUE(Produit d'une quantité un nombre entier de fois par lui-même, la quantité pouvant être un nombre réel ou complexe, une indéterminée, etc. cela sous entends puissance).