Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Moins unaire en C++

Le moins unaire calcule l’opposé d’un opérande. Dans `return -1;`, il produit une valeur de type `int` qui signifie « non trouvé » pour cette fonction, sans effectuer de soustraction.

Version : ISO C++23; implementation support may vary

Syntaxe

-operand
return -1;

Dans -x, le moins unaire intégré calcule l’opposé de x sans modifier l’opérande. Dans -1, 1 est le littéral de type int et - est un opérateur distinct. Dans a - b, le moins est binaire : il soustrait b de a. Dans 4 - -1, le premier moins indique la soustraction et le second la négation arithmétique.

L’opérateur intégré accepte les types arithmétiques et les types énumérés sans portée propre. Les opérandes entiers ou énumérés subissent d’abord une promotion entière ; le résultat a le type de l’opérande après promotion. Un type défini par l’utilisateur peut proposer une surcharge unaire de operator- distincte de la surcharge de soustraction.

Si le type après promotion est non signé, le résultat est calculé modulo 2^N, où N est le nombre de bits de valeur du type. Ainsi, -1u donne la valeur maximale de unsigned int, et non moins un. Prendre l’opposé de la plus petite valeur de type int entraîne un comportement indéfini : son opposé positif n’est pas représentable par un int.

find_index renvoie un indice commençant à zéro, ou -1 si l’élément est introuvable. C’est la valeur sentinelle documentée par cette fonction, pas une règle spéciale du langage. Vérifie le résultat avant de l’utiliser comme indice ou de le convertir en un type non signé.

Exemples

#include <iostream>
#include <limits>

int find_index(int target) {
    constexpr int values[] = {4, 7, 9};
    int index = 0;
    for (int value : values) {
        if (value == target) {
            return index;
        }
        ++index;
    }
    return -1;
}

int main() {
    static_assert(-1u == std::numeric_limits<unsigned int>::max());

    std::cout << find_index(7) << '\n';
    std::cout << find_index(8) << '\n';
    std::cout << (4 - -1) << '\n';
}

Résultat

1
-1
5

`7` se trouve à l’indice `1` ; `8` est absent, donc la fonction renvoie `-1`. La dernière ligne affiche `5`. `static_assert` vérifie la valeur de `-1u` à la compilation et n’affiche rien.

Leçons associées

  • C++ · Leçon 6 · Avancé · Version : 3

Sources