Как вложенные петли работают?

Question

Мне нужна помощь, чтобы понять, как гнездиться для циклов в C++ и как понимать, что происходит?

Может кто-нибудь объяснить мне, что происходит с этими строками кода:

#include <iostream> 
using namespace std; 
int main() { 
    const int MAX_ROWS = 3; 
    const int MAX_COLS = 4; 

    // 2D array of integers 
    int MyInts[MAX_ROWS][MAX_COLS] = {{34, -1, 879, 22}, 
             {24, 365, -101, -1}, 
             {-20, 40, 90, 97}}; 

    // iterate rows, each array of int 
    for (int Row = 0; Row < MAX_ROWS; ++Row) { 
     // iterate integers in each row (columns) 
     for (int Column = 0; Column < MAX_COLS; ++Column) { 
      cout << "Integer[" << Row << "][" << Column << "] = " << MyInts[Row][Column] << endl; 
     } 
    } 

    return 0; 
} 

Как научить себя то, что тройной вложенной цикл делает?

Answer 1

В этом случае он выполняет итерацию массива 2d, где он дает иллюзию фактической таблицы, состоящей из строк и столбцов. Итак, сначала он начинается с первой строки, где индекс равен 0, и переходит ко второму для цикла (столбца) и итерации вокруг него до тех пор, пока он не достигнет столбца max и не вернется в первый цикл for и не перейдет к следующей строке (индекс) и так далее до тех пор, пока он не достигнет максимальной строки, а затем остановится. Надеюсь, что это помогло немного

Answer 2

в какой ситуации вы бы это нужно

обычно вам потребуется вложенным для цикла, когда

у вас есть два (или более) размеры для работы с

for e.g : working with images, x and y dimensions 

       working with matrix 

объяснение кода:

сначала вы выбираете строку для работы с,

то в этой выбранной строке, вы траверс всех столбцов

тогда вы двигаетесь на втором ряду

внешний контур заботится перемещение во второй ряд, когда все столбцы первой строки были обработаны/прочитаны

Внутренняя петля перемещается по столбцам в строке, выбранной внешним контуром

логика позади него:

наружные ждет петля для внутреннего цикла и до конца, а затем переходит к своей собственной следующей итерации.

т. Е. Для каждой итерации внешнего контура внутренний цикл будет охватывать все его итерации.

как в вашем случае, для каждой итерации вашего внешнего цикла внутренний цикл выполняется в течение 4-х раз (число столбцов в каждой строке)

и этот процесс происходит для всех строк, то есть в три раза (номер строк)

Answer 3

Вложенная петля через двумерную матрицу означает, что каждый элемент принадлежит столбцам и повторяется для каждой строки.

Объяснение:

Answer 4

Любая книга на C++, будет иметь главу о зацикливание.

Когда вы «гнездо» две петли, внешняя петля берет на себя управление количеством полных повторений внутреннего цикла. Хотя все типы циклов могут быть вложенными, наиболее часто вложенными циклами являются петли for.

Когда вы имеете дело с 2 - й массив, то есть, который состоит из обоих строки и столбца, вложенный цикл может быть использован.

Пример: У вас есть двумерный массив из трех строк и четырех столбцов, и вам нужно индивидуально обращаться к каждому элементу в массиве по одному элементу на строку.

Как и в вашем коде, у вас есть две петли, где первый цикл итерации по строкам и что делает ваш второй цикл, это то, что он выполняет итерацию через столбцы.

Здесь переменная Ряд во внешнем контуре инициализируется нулевым

Row = 0, это ваш 0th строка, то цикл переходит во внутреннюю петлю, где цикл не выполняется из Column=0, пока условие Column < MAX_COLS будет достигнуто -

Column = 0; будет cout т.е. печать Integer[0][0]=34

Затем Column увеличивается (++Column) и проверить, что, если она меньше, чем MAX_COLS (Column < MAX_COLS;) Если да, то она выводит Integer[номер строки, в которой она находится на][номер столбца, в котором он находится на]=значение в этом месте

Это делается до MAX_COLS, отображая . Затем цикл снова перемещается во внешний цикл, приращение строки (++Row) проверяет, имеет ли значение меньше MAX_ROWS;, и процесс продолжается до MAX_ROWS = 3. Затем останавливается.

Попробуйте этот же пример с разными значениями для строки и столбца и запустите программу в отладке. Вы поймете, что происходит точно.

Выход Вы получаете:

Integer[0][0] = 34 
Integer[0][1] = -1 
Integer[0][2] = 879 
Integer[0][3] = 22 
Integer[1][0] = 24 
Integer[1][1] = 365 
Integer[1][2] = -101 
Integer[1][3] = -1 
Integer[2][0] = -20 
Integer[2][1] = 40  
Integer[2][2] = 90 
Integer[2][3] = 97 

Я действительно надеюсь, что вы получите что-то из этого.