【C++】イテレータを活用する！初心者から上級者までの完全ガイド10選

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        *it = *it * 2;  // 各要素を2倍にする
    }

    // 変更後の要素を出力
    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>  // アルゴリズムのためのヘッダ

int main() {
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    auto it = std::find(numbers.begin(), numbers.end(), 30);

    if (it != numbers.end()) {
        std::cout << "Found: " << *it << "\n";
    } else {
        std::cout << "Not found\n";
    }
    return 0;
}

#include <iostream>

class IntArrayIterator {
public:
    IntArrayIterator(int* ptr) : m_ptr(ptr) {}

    IntArrayIterator& operator++() {
        m_ptr++;
        return *this;
    }

    bool operator!=(const IntArrayIterator& other) const {
        return m_ptr != other.m_ptr;
    }

    int& operator*() const {
        return *m_ptr;
    }

private:
    int* m_ptr;
};

class IntArray {
public:
    IntArray(int* array, int size) : m_array(array), m_size(size) {}

    IntArrayIterator begin() {
        return IntArrayIterator(m_array);
    }

    IntArrayIterator end() {
        return IntArrayIterator(m_array + m_size);
    }

private:
    int* m_array;
    int m_size;
};

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    IntArray array(numbers, 5);

    for (auto it = array.begin(); it != array.end(); ++it) {
        std::cout << *it << " ";
    }
    return 0;
}

#include <iostream>
#include <stack>

template <typename T>
class BinaryTree;

template <typename T>
class BinaryTreeIterator {
public:
    BinaryTreeIterator(BinaryTree<T>* tree) {
        pushLeft(tree);
    }

    bool operator!=(const BinaryTreeIterator& other) const {
        return !m_stack.empty();
    }

    BinaryTreeIterator& operator++() {
        BinaryTree<T>* node = m_stack.top();
        m_stack.pop();
        pushLeft(node->right);
        return *this;
    }

    T& operator*() const {
        return m_stack.top()->value;
    }

private:
    std::stack<BinaryTree<T>*> m_stack;

    void pushLeft(BinaryTree<T>* node) {
        while (node != nullptr) {
            m_stack.push(node);
            node = node->left;
        }
    }
};

template <typename T>
class BinaryTree {
public:
    BinaryTree(T val) : value(val), left(nullptr), right(nullptr) {}

    BinaryTreeIterator<T> begin() {
        return BinaryTreeIterator<T>(this);
    }

    static BinaryTreeIterator<T> end() {
        return BinaryTreeIterator<T>(nullptr);
    }

    T value;
    BinaryTree* left;
    BinaryTree* right;
};

int main() {
    BinaryTree<int> root(1);
    root.left = new BinaryTree<int>(2);
    root.right = new BinaryTree<int>(3);

    for (auto it = root.begin(); it != root.end(); ++it) {
        std::cout << *it << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    auto it = numbers.begin();

    // イテレータが末尾を指しているかどうかを確認
    if (it != numbers.end()) {
        std::cout << *it << "\n";
    } else {
        std::cerr << "Iterator is at the end of the vector.\n";
    }
    return 0;
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    auto it = numbers.begin();

    // イテレータの位置を確認
    while (it != numbers.end()) {
        std::cout << "Iterator at position: " << (it - numbers.begin()) << "\n";
        ++it;
    }
    return 0;
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // イテレータを効率的に使用する
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        *it = *it * 2;  // 各要素を2倍にする
    }

    // 結果を出力
    for (auto num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>

// 2つの要素を交互に返すカスタムイテレータ
template <typename T>
class AlternateIterator {
public:
    AlternateIterator(std::vector<T>& vec) : m_vec(vec), m_index(0) {}

    T& operator*() {
        return m_vec[m_index];
    }

    AlternateIterator& operator++() {
        m_index = (m_index + 2) % m_vec.size();
        return *this;
    }

    bool operator!=(const AlternateIterator& other) const {
        return m_index != other.m_index;
    }

private:
    std::vector<T>& m_vec;
    size_t m_index;
};

template <typename T>
AlternateIterator<T> MakeAlternateIterator(std::vector<T>& vec) {
    return AlternateIterator<T>(vec);
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};

    // カスタムイテレータを使用して、交互の要素を出力
    for (auto it = MakeAlternateIterator(numbers); it != MakeAlternateIterator(numbers); ++it) {
        std::cout << *it << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 奇数のみを抽出するイテレータを作成
    auto is_odd = [](int n) { return n % 2 != 0; };
    auto it = std::find_if(data.begin(), data.end(), is_odd);

    // 奇数の要素を出力
    while (it != data.end()) {
        std::cout << *it << " ";
        it = std::find_if(std::next(it), data.end(), is_odd);
    }

    return 0;
}