C++ std::move は何も移動しない：値カテゴリに関する詳細な検証

問題点：最適化が逆に処理を遅くしてしまうケース

まず、経験豊富な開発者でもつまづきやすいポイントから始めましょう。以下のコードは一見合理的に見えるC++です。

struct HeavyObject {
    std::string data;

    HeavyObject(HeavyObject&& other) : data(std::move(other.data)) {}

    HeavyObject(const HeavyObject& other) : data(other.data) {}
    
    HeavyObject(const char* s) : data(s) {}
};

std::vector<HeavyObject> createData() {
    std::vector<HeavyObject> data;
    // … データを埋める …
    return data;
}

void processData() {
    auto result = createData();
}

このコードは動作します。コンパイルも通り、実行時に問題が生じるわけではありません。しかし、型の実装次第でコピー操作が数千回発生し、ムーブよりずっと重い処理になってしまう可能性があります。

実際に起きていることはこうです。

std::vector

noexcept

std::vector

• コピー中に例外が投げられた場合、元のベクターは破損せずそのまま残ります。
• ムーブ中に例外が投げられると、一部の要素だけムーブ済みになり、元のベクターが壊れてしまう恐れがあります。

したがって、ムーブコンストラクタを

noexcept

1. 実際に

std::move

は何をするのか？

template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept {
    return static_cast<typename std::remove_reference<_Tp>::type&&>(__t);
}

std::move

2. 値カテゴリを理解する

int x = 5; std::string name = "Alice";

42

5 + 3

std::string("hello")

std::move

std::move(name)

name

3. パフォーマンスを損なうよくあるミス

std::move

cpp\nstd::string createString() {\n    std::string result = "expensive data";\n    return std::move(result); // ❌\n}\n

const

cpp\nconst std::vector<int> data = getData();\nconsume(std::move(data)); // ❌ コピー！\n

const

cpp\nstd::string a = "hello";\nstd::string b = std::move(a); // a は「有効だが未定義」の状態になる。\n

4. ムーブセマンティクスを正しく実装する

Rule of Five

次の特殊メンバ関数を1つ定義したら、通常はすべて5つを用意します。

• デストラクタ
• コピーコンストラクタ
• コピー代入演算子
• ムーブコンストラクタ
• ムーブ代入演算子

class Resource {
    int* data;
    size_t size;

public:
    Resource(size_t n) : data(new int[n]), size(n) {}
    ~Resource() { delete[] data; }

    // コピー操作
    Resource(const Resource& other)
        : data(new int[other.size]), size(other.size) {
        std::copy(other.data, other.data + size, data);
    }
    Resource& operator=(const Resource& other) {
        if (this != &other) {
            int* new_data = new int[other.size];
            std::copy(other.data, other.data + other.size, new_data);
            delete[] data;
            data = new_data;
            size = other.size;
        }
        return *this;
    }

    // ムーブ操作（noexcept）
    Resource(Resource&& other) noexcept
        : data(std::exchange(other.data, nullptr)),
          size(std::exchange(other.size, 0)) {}
    Resource& operator=(Resource&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = std::exchange(other.data, nullptr);
            size = std::exchange(other.size, 0);
        }
        return *this;
    }
};

ポイント

• std::exchange

  を使って、ムーブ元のリソースを安全に「空」にしておく。
• ムーブ操作は必ず

  noexcept

  にする。そうしないとコンテナがコピーに戻る。

5.

std::move

と

std::forward

の使い分け

std::move

std::forward

6. 実務チェックリスト

• 返却時に

  std::move

  を使わない。NRVO や暗黙ムーブが最適化。
• ムーブコンストラクタ／代入演算子は 必ず

  noexcept

  にする。

• const

  オブジェクトに対しては

  std::move

  を呼ばない。
• ムーブ後のオブジェクトは「再代入」か「破棄」以外には使わない。
• テンプレートで完璧転送が必要な場合のみ

  std::forward

  を使用。

7. 実例：ムーブ対応動的配列

template<typename T>
class DynamicArray {
    T* data_;
    size_t size_, capacity_;

    void reserve_more() {
        size_t new_cap = capacity_ == 0 ? 1 : capacity_ * 2;
        T* new_data = new T[new_cap];
        for (size_t i = 0; i < size_; ++i)
            new_data[i] = std::move(data_[i]); // 要素をムーブ
        delete[] data_;
        data_ = new_data;
        capacity_ = new_cap;
    }

public:
    DynamicArray() : data_(nullptr), size_(0), capacity_(0) {}
    ~DynamicArray() { delete[] data_; }

    // コピー操作
    DynamicArray(const DynamicArray& other)
        : data_(new T[other.capacity_]), size_(other.size_), capacity_(other.capacity_) {
        std::copy(other.data_, other.data_ + size_, data_);
    }
    DynamicArray& operator=(const DynamicArray& other) {
        if (this != &other) {
            T* new_data = new T[other.capacity_];
            std::copy(other.data_, other.data_ + other.size_, new_data);
            delete[] data_;
            data_ = new_data;
            size_ = other.size_;
            capacity_ = other.capacity_;
        }
        return *this;
    }

    // ムーブ操作（noexcept）
    DynamicArray(DynamicArray&& other) noexcept
        : data_(std::exchange(other.data_, nullptr)),
          size_(std::exchange(other.size_, 0)),
          capacity_(std::exchange(other.capacity_, 0)) {}
    DynamicArray& operator=(DynamicArray&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_ = std::exchange(other.data_, nullptr);
            size_ = std::exchange(other.size_, 0);
            capacity_ = std::exchange(other.capacity_, 0);
        }
        return *this;
    }

    void push_back(const T& v) { if (size_==capacity_) reserve_more(); data_[size_++] = v; }
    void push_back(T&& v)   { if (size_==capacity_) reserve_more(); data_[size_++] = std::move(v); }

    // … アクセサ、size()、capacity() など …
};

このクラスは Rule of Five を守り、ムーブ操作を

noexcept

8. まとめ

• std::move

  はキャストで値カテゴリを変えるだけ。実際のデータ移動は後続のムーブコンストラクタ／代入演算子が行う。
• 不要な

  std::move

  を避ける。NRVO や暗黙ムーブに任せれば高速で安全。
• ムーブ操作を必ず

  noexcept

  にする。そうしないとコンテナはコピーへフォールバック。

• const

  オブジェクトからはムーブできない。コピーが発生するので注意。
• ムーブ後のオブジェクトは「再代入」か「破棄」のみで扱う。

これらを頭に入れれば、ムーブセマンティクスを正しく活用しつつ、高速で安全な C++ コードを書けるようになります。