Pourquoi le signe moins, "-", n'est-il généralement pas surchargé de la même manière que le signe plus?

Le signe plus +est utilisé pour l’addition et pour la concaténation de chaînes, mais son compagnon: le signe moins,, -n’est généralement pas utilisé pour le rognage de chaînes ou pour un autre cas autre que la soustraction. Quelle pourrait être la raison ou les limites de cela?

Considérez l'exemple suivant en JavaScript:

var a = "abcdefg";
var b = "efg";

a-b == NaN
// but
a+b == "abcdefgefg"

En bref, il n’ya pas d’opérations de soustraction sur les chaînes particulièrement utiles avec lesquelles les gens ont voulu écrire des algorithmes.

L’ +opérateur dénote généralement le fonctionnement d’un monoïde additif , c’est-à-dire une opération associative avec un élément d’identité:

• A + (B + C) = (A + B) + C
• A + 0 = 0 + A = A

Il est logique d'utiliser cet opérateur pour des opérations telles que l'addition d'entiers, la concaténation de chaînes et la définition de l'union, car elles ont toutes la même structure algébrique:

1 + (2 + 3) == (1 + 2) + 3
1 + 0 == 0 + 1 == 1

"a" + ("b" + "c") == ("a" + "b") + "c"
"a" + "" == "" + "a" == "a"

Et nous pouvons l’utiliser pour écrire des algorithmes pratiques, comme une concatfonction qui fonctionne sur une séquence de choses «concaténables», par exemple:

def concat(sequence):
    return sequence.reduce(+, 0)

Lorsque la soustraction -est impliquée, vous parlez généralement de la structure d'un groupe , ce qui ajoute un inverse -A pour chaque élément A, de sorte que:

• A + −A = −A + A = 0

Et bien que cela ait un sens pour des choses comme la soustraction de nombres entiers et flottants, ou même pour la différence de valeurs, cela n'a pas beaucoup de sens pour les chaînes et les listes. Quel est l'inverse de "foo"?

Il existe une structure appelée monoïde d'annulation , qui n'a pas d'inverse, mais possède la propriété d' annulation , de sorte que:

• A - A = 0
• A - 0 = A
• (A + B) - B = A

C'est la structure que vous décrivez, où "ab" - "b" == "a", mais "ab" - "c"n'est pas définie. C'est juste que nous n'avons pas beaucoup d'algorithmes utiles qui utilisent cette structure. J'imagine que si vous envisagez la concaténation comme une sérialisation, la soustraction peut être utilisée pour une sorte d'analyse syntaxique.

Parce que la concaténation de deux chaînes valides est toujours une opération valide, mais l'inverse n'est pas vrai.

var a = "Hello";
var b = "World";

Que devrait a - bêtre ici? Il n'y a vraiment aucun moyen de répondre à cette question, car la question elle-même n'est pas valide.

Parce que l' -opérateur de manipulation de chaîne n'a pas assez de "cohésion sémantique". Les opérateurs ne doivent être surchargés que lorsque la surcharge des opérandes est clairement définie et que la soustraction de chaînes ne respecte pas cette barre.

Par conséquent, les appels de méthode sont préférés:

public string Remove(string source, string toRemove)
public string Replace(string source, string oldValue, string newValue)

En langage C #, nous utilisons +pour la concaténation de chaînes car la forme

var result = string1 + string2 + string3;

au lieu de

var result = string.Concat(string1, string2, string3);

est pratique et peut-être plus facile à lire, même si un appel de fonction est probablement plus "correct", d’un point de vue sémantique.

L' +opérateur ne peut vraiment signifier qu'une chose dans ce contexte. Ce n'est pas aussi vrai -car la notion de soustraction de chaînes est ambiguë (l'appel de la fonction Replace(source, oldValue, newValue)avec ""comme newValueparamètre supprime tout doute, et la fonction peut être utilisée pour modifier des sous-chaînes, pas seulement pour les supprimer).

Le problème, bien sûr, est que la surcharge de l'opérateur dépend des types qui lui sont transmis. Si vous transmettez une chaîne où un nombre aurait dû être, vous risquez d'obtenir un résultat inattendu. En outre, pour de nombreuses concaténations (dans une boucle, par exemple), un StringBuilderobjet est préférable, car chaque utilisation de +crée une nouvelle chaîne et les performances peuvent en souffrir. Donc, l' +opérateur n'est même pas approprié dans tous les contextes.

Il existe des surcharges d'opérateurs qui ont une meilleure cohésion sémantique que l' +opérateur pour la concaténation de chaînes. En voici un qui ajoute deux nombres complexes:

public static Complex operator +(Complex c1, Complex c2) 
{
    return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
}

Le langage Groovy permet -:

println('ABC'-'B')

résultats:

AC

Et:

println( 'Hello' - 'World' )

résultats:

Hello

Et:

println('ABABABABAB' - 'B')

résultats:

AABABABAB

Le signe plus a probablement un sens contextuel dans un plus grand nombre de cas, mais un contre-exemple (peut-être une exception qui prouve la règle) en Python est l'objet set, qui fournit, -mais non +:

>>> set('abc') - set('bcd')
set(['a'])
>>> set('abc') + set('bcd')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'set' and 'set'

Il n’a pas de sens d’utiliser le +signe parce que l’intention peut être ambiguë. Est-ce que cela signifie une intersection ou une union? Au lieu de cela, il utilise |pour l'union et &pour l'intersection:

>>> set('abc') | set('bcd')
set(['a', 'c', 'b', 'd'])
>>> set('abc') & set('bcd')
set(['c', 'b'])

" -" est utilisé dans certains mots composés (par exemple, "sur site") pour joindre les différentes parties dans le même mot. Pourquoi n'utilisons-nous pas " -" pour joindre différentes chaînes dans les langages de programmation? Je pense que cela aurait un sens parfait! Au diable cette +absurdité!

Cependant, essayons de voir cela sous un angle un peu plus abstrait.

Comment définiriez-vous l'algèbre des cordes? Quelles opérations auriez-vous et quelles lois leur seraient applicables? Quelles seraient leurs relations?

Rappelez-vous, il n’ya peut-être aucune ambiguïté! Tous les cas possibles doivent être bien définis, même si cela signifie qu'il n'est pas possible de le faire! Plus votre algèbre est petite, plus cela est facile.

Par exemple, que signifie réellement ajouter ou soustraire deux chaînes?

Si vous ajoutez deux chaînes (par exemple, let a = "aa"et b = "bb"), obtiendriez-vous aabble résultat de a + b?

Que diriez- b + avous Serait-ce bbaa? Pourquoi ne pas aabb? Que se passe-t-il si vous soustrayez aadu résultat de votre addition? Votre chaîne aurait-elle un concept de quantité négative de aa?

Revenez maintenant au début de cette réponse et remplacez-la spaceshuttlepar la chaîne. Pour généraliser, pourquoi toute opération définie ou non définie pour un type quelconque?

Ce que j'essaie de dire, c'est que rien ne vous empêche de créer une algèbre. Il peut être difficile de trouver des opérations significatives, voire utiles.

Pour les cordes, la concaténation est à peu près la seule chose sensée que j'ai jamais rencontrée. Peu importe quel symbole est utilisé pour représenter l'opération.