Как работает диапазон на основе для простых массивов?

Question 1

В C ++ 11 вы можете использовать диапазон for, который действует как foreachдругие языки. Он работает даже с простыми массивами C:

int numbers[] = { 1, 2, 3, 4, 5 };
for (int& n : numbers) {
    n *= 2;
}

Как он узнает, когда остановиться? Работает ли он только со статическими массивами, которые были объявлены в той же области, в forкоторой используется? Как бы вы использовали это forс динамическими массивами?

Question 2

Он работает для любого выражения, тип которого является массивом. Например:

int (*arraypointer)[4] = new int[1][4]{{1, 2, 3, 4}};
for(int &n : *arraypointer)
  n *= 2;
delete [] arraypointer;

Для более подробного объяснения, если тип выражения, переданного справа от, :является типом массива, то цикл повторяется от ptrдо ptr + size( ptrуказывая на первый элемент массива, sizeявляющийся количеством элементов массива).

Это контрастирует с пользовательскими типами, которые работают путем поиска beginи в endкачестве членов, если вы передаете объект класса или (если нет членов, вызываемых таким образом) функции, не являющиеся членами. Эти функции будут давать начальный и конечный итераторы (указывающие непосредственно после последнего элемента и начала последовательности соответственно).

Этот вопрос проясняет, почему существует такая разница.

Question 3

Я думаю, что самая важная часть этого вопроса заключается в том, как C ++ знает, каков размер массива (по крайней мере, я хотел знать это, когда нашел этот вопрос).

C ++ знает размер массива, потому что это часть определения массива - это тип переменной. Компилятор должен знать тип.

Поскольку C ++ 11 std::extentможно использовать для получения размера массива:

int size1{ std::extent< char[5] >::value };
std::cout << "Array size: " << size1 << std::endl;

Конечно, в этом нет особого смысла, потому что вы должны явно указать размер в первой строке, который затем вы получите во второй строке. Но вы также можете использовать, decltypeи тогда будет интереснее:

char v[] { 'A', 'B', 'C', 'D' };
int size2{ std::extent< decltype(v) >::value };
std::cout << "Array size: " << size2 << std::endl;

Question 4

Согласно последнему рабочему проекту C ++ (n3376), оператор range for эквивалентен следующему:

{
    auto && __range = range-init;
    for (auto __begin = begin-expr,
              __end = end-expr;
            __begin != __end;
            ++__begin) {
        for-range-declaration = *__begin;
        statement
    }
}

Таким образом, он знает, как остановить так же, как и обычный forцикл с использованием итераторов.

Я думаю, вы можете искать что-то вроде следующего, чтобы предоставить способ использования вышеуказанного синтаксиса с массивами, которые состоят только из указателя и размера (динамические массивы):

template <typename T>
class Range
{
public:
    Range(T* collection, size_t size) :
        mCollection(collection), mSize(size)
    {
    }

    T* begin() { return &mCollection[0]; }
    T* end () { return &mCollection[mSize]; }

private:
    T* mCollection;
    size_t mSize;
};

Затем этот шаблон класса можно использовать для создания диапазона, по которому вы можете выполнять итерацию, используя новый синтаксис диапазона . Я использую это для просмотра всех объектов анимации в сцене, которая импортируется с использованием библиотеки, которая возвращает только указатель на массив и размер как отдельные значения.

for ( auto pAnimation : Range<aiAnimation*>(pScene->mAnimations, pScene->mNumAnimations) )
{
    // Do something with each pAnimation instance here
}

Этот синтаксис, на мой взгляд, намного понятнее, чем тот, который вы бы использовали std::for_eachили простой forцикл.

Question 5

Он знает, когда остановиться, потому что знает границы статических массивов.

Я не уверен, что вы имеете в виду под «динамическими массивами», в любом случае, если не выполнять итерацию по статическим массивам, неофициально, компилятор просматривает имена beginи endв области класса объекта, который вы повторяете, или просматривает до begin(range)иend(range) с помощью аргумента-зависимого поиска и используют их в качестве итераторов.

Дополнительные сведения см. В стандарте C ++ 11 (или его общедоступной версии), «6.5.4 Оператор на основе диапазона for», стр. 145

Question 6

Как работает диапазон на основе для простых массивов?

Это должно читаться как " Скажите, что делает ранжированный (с массивами)? "

Я отвечу, предполагая, что - возьмите следующий пример с использованием вложенных массивов:

int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

for (auto &pl : ia)

Текстовая версия:

iaпредставляет собой массив массивов («вложенный массив»), содержащий [3]массивы, каждый из которых содержит [4]значения. В приведенном выше примере iaвыполняется цикл с помощью его основного 'range' ( [3]), и, следовательно, [3]время цикла . Каждый контур производит один из ia«S [3]первичных значений , начиная с первой и заканчивая последней - массив , содержащий [4]значения.

Первый цикл: plравно {1,2,3,4}- массив
Второй цикл: plравно {5,6,7,8}- массив
Третий цикл: plравно {9,10,11,12}- массив

Прежде чем мы объясним процесс, вот несколько простых напоминаний о массивах:

Массивы интерпретируются как указатели на их первое значение - использование массива без какой-либо итерации возвращает адрес первого значения.
pl должен быть ссылкой, потому что мы не можем копировать массивы
С массивами, когда вы добавляете число к самому объекту массива, он продвигается вперед столько раз и `` указывает '' на эквивалентную запись - если nэто число, о котором идет речь, то ia[n]это то же самое, что и *(ia+n)(Мы разыменуем адрес, который nзаписи вперед) и ia+nсовпадает с &ia[n](Мы получаем адрес этой записи в массиве).

Вот что происходит:

На каждом цикле, plустанавливается в качестве ссылки на ia[n], с nсравнявшись текущее значение счетчика цикла , начиная с 0. Итак, plнаходится ia[0]на первом раунде, на втором онia[1] , и так далее. Он получает значение через итерацию.
Цикл продолжается до тех пор, ia+nпока меньше end(ia).

... И это все.

На самом деле это просто упрощенный способ написать это :

int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (int n = 0; n != 3; ++n)
  auto &pl = ia[n];

Если ваш массив не вложен, этот процесс становится немного проще, поскольку ссылка не требуется, потому что повторяемое значение не является массивом, а скорее `` нормальным '' значением:

 int ib[3] = {1,2,3};

 // short
 for (auto pl : ib)
   cout << pl;

 // long
 for (int n = 0; n != 3; ++n)
   cout << ib[n];

Дополнительная информация

Что, если бы мы не хотели использовать autoключевое слово при создании pl? Как бы это выглядело?

В следующем примере plотносится к array of four integers. Каждому циклу plприсваивается значение ia[n]:

int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (int (&pl)[4] : ia)

И ... Вот как это работает, с дополнительной информацией, чтобы избавиться от путаницы. Это просто «сокращенный» forцикл, который автоматически засчитывается для вас, но не имеет возможности получить текущий цикл без выполнения этого вручную.

Question 7

Пример кода, демонстрирующий разницу между массивами в стеке и массивами в куче


/**
 * Question: Can we use range based for built-in arrays
 * Answer: Maybe
 * 1) Yes, when array is on the Stack
 * 2) No, when array is the Heap
 * 3) Yes, When the array is on the Stack,
 *    but the array elements are on the HEAP
 */
void testStackHeapArrays() {
  int Size = 5;
  Square StackSquares[Size];  // 5 Square's on Stack
  int StackInts[Size];        // 5 int's on Stack
  // auto is Square, passed as constant reference
  for (const auto &Sq : StackSquares)
    cout << "StackSquare has length " << Sq.getLength() << endl;
  // auto is int, passed as constant reference
  // the int values are whatever is in memory!!!
  for (const auto &I : StackInts)
    cout << "StackInts value is " << I << endl;

  // Better version would be: auto HeapSquares = new Square[Size];
  Square *HeapSquares = new Square[Size];   // 5 Square's on Heap
  int *HeapInts = new int[Size];            // 5 int's on Heap

  // does not compile,
  // *HeapSquares is a pointer to the start of a memory location,
  // compiler cannot know how many Square's it has
  // for (auto &Sq : HeapSquares)
  //    cout << "HeapSquare has length " << Sq.getLength() << endl;

  // does not compile, same reason as above
  // for (const auto &I : HeapInts)
  //  cout << "HeapInts value is " << I << endl;

  // Create 3 Square objects on the Heap
  // Create an array of size-3 on the Stack with Square pointers
  // size of array is known to compiler
  Square *HeapSquares2[]{new Square(23), new Square(57), new Square(99)};
  // auto is Square*, passed as constant reference
  for (const auto &Sq : HeapSquares2)
    cout << "HeapSquare2 has length " << Sq->getLength() << endl;

  // Create 3 int objects on the Heap
  // Create an array of size-3 on the Stack with int pointers
  // size of array is known to compiler
  int *HeapInts2[]{new int(23), new int(57), new int(99)};
  // auto is int*, passed as constant reference
  for (const auto &I : HeapInts2)
    cout << "HeapInts2 has value " << *I << endl;

  delete[] HeapSquares;
  delete[] HeapInts;
  for (const auto &Sq : HeapSquares2) delete Sq;
  for (const auto &I : HeapInts2) delete I;
  // cannot delete HeapSquares2 or HeapInts2 since those arrays are on Stack
}