问题[c++]

让我们想象一个存储数值的嵌套（二维）10x10 数组。我通常看到的迭代值的经典方法是嵌套循环，顺序读取第一个“行”的元素，然后转到下一个。

如果这些行中的每一行都占用一个单独的内存区域，则将有 10 次通过这些区域的转换，以及对行中各个元素的 10 次访问。
（模式：元素=数组[X][Y]）

据我所知，访问行（X）比访问其中的元素（Y）花费更多的计算资源。

问题： 当非顺序访问数组元素时，并且行间跳转更加频繁（总共会产生超过 10 次转换），搜索时间会增加吗？

我刚刚开始学习 C++，从一开始就遇到了问题。我所写的一切都与培训视频中的完全一样。

#include <iostream>
#include <stdio.h>
using namespace std;
int main()
{
    int a, b;
    scanf("%d%d", &a, &b);
    printf("sum = %d\n", a+b);

    return 0;
}

函数中有这样一行代码：

static int* criterion_table = new int[length];

我感兴趣的是如何释放从堆捕获的数据（这是在程序结束时自动完成的还是有必要自己执行），并且希望堆上数据的初始化始终发生是否安全？零还是取决于编译器

有一个场景是经典的相机投影+视图+模型。

任务：不是在 3D 世界的空间中，而是在 2D 屏幕的空间中绘制对象（文本）。

示例：我们在 3D 投影中选择一个对象，文本信息应在正交投影中绘制，就像在所选对象旁边一样。

现在我们必须在 3D 空间中绘制文本并将其转向相机。不是那样的。

我假设您可以通过矩阵将文本块的坐标转换为屏幕坐标。谢谢。

我正在编写一个程序来查找序列中的局部极值。从算法的角度来看，这很简单，但是会出现错误：

C2677   бинарный "==": не найден глобальный оператор, принимающий тип "const _Ty" (или приемлемое преобразование отсутствует)
        with
        [
            _Ty=std::_Vector_iterator<std::_Vector_val<std::_Simple_types<int>>>
        ]   Project1    C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.41.34120\include\xutility  6010

    

我解决问题的完整代码：

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

using namespace std;

int main()
{
    vector<int> vec;

    int a, b;

    cin >> a;

    for (int i = 0; i < a; ++i) {
        cin >> b;
        vec.push_back(b);
    }

    vector<long long> mins;
    vector<long long> maxs;

    int cnt_min = 0, cnt_max = 0;

    for (int i = 0; i < a; i++) {
        if (i == 0) {
            if (vec[i] < vec[i + 1]) {
                cnt_min++;
                mins.push_back(i + 1);
            }
            else if (vec[i] > vec[i + 1]) {
                cnt_max++;
                maxs.push_back(i + 1);
            }
        }
        else if (i == vec.size()) {
            if (vec[i] < vec[i - 1]) {
                cnt_min++;
                mins.push_back(i + 1);
            }
            else if (vec[i] > vec[i - 1]) {
                cnt_max++;
                maxs.push_back(i + 1);
            }
        }
        else {
            if (vec[i - 1] > vec[i] < vec[i + 1]) {
                cnt_min++;
                mins.push_back(i + 1);
            }
            else if (vec[i - 1] < vec[i] > vec[i + 1]) {
                cnt_max++;
                maxs.push_back(i + 1);
            }
        }
    }

    cout << cnt_min;

    for (int i = 0; i < mins.size(); ++i) {
        cout << ' ' << mins[i];
    }

    cout << "\n" << cnt_max;

    for (int i = 0; i < maxs.size(); ++i) {
        cout << ' ' << maxs[i];
    }

    cout << "\n" << vec.end() - find(vec.begin(), vec.end(), min(vec.begin(), vec.end()));
    cout << ' ' << vec.end() - find(vec.begin(), vec.end(), max(vec.begin(), vec.end()));

    return 0;
}