c++ - C++基于范围的for循环会调用迭代器的析构函数吗？

Question

当尝试实现双指针的迭代器时，我发现了一些有趣的事情:

• 调用析构函数的时间让我感到困惑。
• 无法理解对象的内存地址。

<小时/>

说明

A 类

我有一个名为 A 的类，它将为整数序列 ( _ori_aa ) 分配一些内存。

class A {
public:
    // constructor and destructor
    // ...
    Iter<int> aa() const {
        Iter<int> _iter;
        _iter.set(_aa, _len);
        return _iter;
    }
private:
    const int _len;
    int * _ori_aa;  // sequence of numbers: {0, 1, 2, 3}
    int ** _aa;     // pointers to _ori_aa: {_ori_aa, _ori_aa+1, ...}
};

<小时/>

结构Iter

还有一个名为 Iter 的结构，它可以帮助我迭代 A 对象中的双指针 _aa。

为了观察，我在构造函数和析构函数中打印了自身的内存地址 ( this )。

函数meow()也打印内存地址，但它用于手动调用。

template <typename T>
struct Iter {
    Iter() { cout << '+' << this << endl; }
    ~Iter() { cout << '-' << this << endl; }
    // ...
    void meow() {
        cout << '?' << this << endl;
    }
    // ...
};

<小时/>

main()

在主函数中，

1. 我创建一个 A 对象，然后调用 aa()，这将生成一个 Iter 对象并按值返回。
2. 我创建了一个 Iter 对象，并手动调用 meow() 来查看其地址。
3. 我使用基于范围的 for 循环来打印所有数字。
4. 我打印一个分隔符来指示循环结束。

int main() {
    A a;
    Iter<int> aa = a.aa();      // copy by value
    aa.meow();
    for(const int & n : aa) {
        cout << n << endl;
    }
    cout << "-------" << endl;
}

<小时/>

问题

这是程序的输出:

+0x7ffee567a9b0
?0x7ffee567a9b0
0
1
2
3
-0x7ffee567a988
-------
-0x7ffee567a9b0

我的问题是:

1. 这些打印的地址对应什么操作？
2. 我知道在aa()中创建_iter时会打印第一个地址，但是什么时候调用析构函数？我以为 _iter 会在 aa() 返回后被销毁，但事实似乎并非如此。
3. 我认为当对象aa(main()中的局部变量)被销毁时，会打印最后一个地址。既然和_iter的地址相同，是否意味着_iter的内存已经被释放了呢？那为什么析构函数没有被调用呢？
4. 第三个地址是什么？为什么它与构造函数打印的所有地址不同？为什么在 for 循环结束时调用析构函数？

<小时/>

环境

• 操作系统:macOS Catalina
• Apple clang 版本 11.0.3 (clang-1103.0.32.29)
• 编译选项:-std=c++17

<小时/>

代码

以下是完整代码，

#include <iostream>

using namespace std;

template <typename T>
struct Iter {
    Iter() { cout << '+' << this << endl; }
    ~Iter() { cout << '-' << this << endl; }

    T ** pp {nullptr};
    int len {0};
    int it {0};

    void meow() {
        cout << '?' << this << endl;
    }
    void set(T ** pi, int l) {
        pp = pi;
        len = l;
    }
    Iter & begin() {
        it = 0;
        return *this;
    }
    int end() const {
        return len;
    }

    T & operator*() {
        return *pp[it];
    }
    bool operator!=(int rhs) {
        return this->it < rhs;
    }
    Iter & operator++() {
        ++it;
        return *this;
    }
};

class A {
public:
    A() : _len(4) {
        _ori_aa = new int [_len];
        _aa = new int * [_len];
        for(int i = 0; i < _len; i++) {
            _ori_aa[i] = i;
            _aa[i] = _ori_aa + i;
        }
    }
    ~A() {
        delete [] _aa;
        delete [] _ori_aa;
    }
    Iter<int> aa() const {
        Iter<int> _iter;
        _iter.set(_aa, _len);
        return _iter;
    }
private:
    const int _len;
    int * _ori_aa;
    int ** _aa;
};

int main() {
    A a;
    Iter<int> aa = a.aa();      // copy by value
    aa.meow();
    for(const int & n : aa) {
        cout << n << endl;
    }
    cout << "-------" << endl;
}

感谢您的阅读!

Answer 1

基于范围的 for 语句:

for (const int & n : aa) {
    cout << n << endl;
}

只是以下内容的语法糖(请参阅 cppref ):

{
    auto&& __range = aa;
    auto __begin = __range.begin();
    auto __end = __range.end();
    for (; __begin != __end; ++__begin) {
        const int & n = *__begin;
        cout << n << endl;
    }
}

这应该可以帮助您了解您的其他 Iter正在 build 的地方以及正在被摧毁的地方。

请注意，正好有两个 Iter该程序中正在构造的对象:名为 aa 的对象以及脱糖 for 语句中名为 __begin 的语句。名为_iter的那个aa()里面就地 build 于 aa .