Avertissement C26800

Utilisation d’un objet déplacé à partir de l’objet : 'objet'.

Notes

L’avertissement C26800 est déclenché lorsqu’une variable est utilisée après son déplacement. Une variable est considérée comme déplacée après son passage à une fonction comme référence rvalue. Il existe quelques exceptions pour l’affectation, la destruction et certaines fonctions de réinitialisation d’état telles que std::vector::clear. Après avoir utilisé une fonction de réinitialisation d’état, nous sommes libres d’utiliser la variable. Cela case activée uniquement des raisons relatives aux variables locales.

Les méthodes suivantes sont considérées comme des méthodes de réinitialisation d’état :

• Fonctions avec la sous-chaîne ne respectant pas la casse suivante dans leur nom : clear, , clean, reset, free, destroyrelease, , , deallocassign
• Opérateurs d’affectation surchargés, destructeur

Cette case activée respecte l’opération std::swap :

void f() {
    Y y1, y2;
    consume(std::move(y1));
    std::swap(y1, y2);
    y1.method();                  // OK, valid after swap.
    y2.method();                  // warning C26800
}

Le case activée prend également en charge les try_emplace opérations dans STL qui déplacent conditionnellement son argument :

int g() {
  std::map<int, Y> m;
  Y val;
  auto emplRes = m.try_emplace(1, std::move(val));
  if (!emplRes.second) {
    val.method();  // No C26800, val was not moved because the insertion did not happen.
  }
}

Nom de l’analyse du code : USE_OF_A_MOVED_FROM_OBJECT

Exemples

Le code suivant génère l’erreur C26800.

#include <utility>

struct X {
    X();
    X(const X&);
    X(X&&);
    X &operator=(X&);
    X &operator=(X&&);
    ~X();
};

template<typename T>
void use_cref(const T&);

void test() {
    X x1;
    X x2 = std::move(x1);
    use_cref(x1);                // warning C26800
}

Le code suivant ne génère pas C26800.

#include <utility>

struct MoveOnly {
    MoveOnly();
    MoveOnly(MoveOnly&) = delete;
    MoveOnly(MoveOnly&&);
    MoveOnly &operator=(MoveOnly&) = delete;
    MoveOnly &operator=(MoveOnly&&);
    ~MoveOnly();
};

template<typename T>
void use(T);

void test() {
    MoveOnly x;
    use(std::move(x)); // no 26800
}