C++ 二维数组和迭代器c++；_C++

C++ 二维数组和迭代器c++；

c++

C++ 二维数组和迭代器c++；,c++,C++,我想获取std列表的内容，并通过迭代器通过2x10数组传递它们，它应该从元素[2][10]开始 @Suthiro非常友好地提供了这段代码，它适用于从元素[0][0]向前移动的元素 auto jj = 1u; while (!condition) { intarray[0][0] = *it; ++it; for (auto ii=jj; ii >= 1 ; --ii) intarray[0][ii] = intarray[0][ii-1]; ++jj; } 所以我尝试了各种可能的

我想获取std列表的内容，并通过迭代器通过2x10数组传递它们，它应该从元素[2][10]开始

@Suthiro非常友好地提供了这段代码，它适用于从元素[0][0]向前移动的元素

auto jj = 1u;
while (!condition)
{
intarray[0][0] = *it;
++it;
for (auto ii=jj; ii >= 1 ; --ii)
    intarray[0][ii] = intarray[0][ii-1];
++jj;
}

所以我尝试了各种可能的变化

我想我得到的最接近的是这一块

FileList = List;
auto jj = 1;

it = begin(FileList);
std::advance(it, 10);

for (auto& i : FileList) {
    FileArray[1][9] = *it;
    ++it;
    for (auto ii = 19; ii>=1; --ii)
    {
        FileArray[0][ii - 1] = FileArray[0][ii];
        ++jj;
 }

我已经通过断点来尝试解决问题，但经过了很多小时，我开始寻求帮助。

好的，据我所知，您希望将

std:：list

中的值分配给二维数组。我希望你是指<代码> STD:：数组，而不是C++中不应该使用的C样式数组。但是，我担心你指的是C型数组

无论如何，我将向您展示3种解决方案

使用C++ <代码> STD:：数组< /C> >并用迭代器< /LI>做所有操作

使用C样式数组并使用索引运算符

使用C样式数组并使用指针，类似于迭代器

我们将从头到尾填充阵列

< C++ >迭代器，这是非常简单的，因为我们可以使用所谓的<代码> RealSythIdor < /C>。如果使用

rbegin（）

对其进行初始化，则它将指向最后一个元素。增加它（++）实际上将转到上一个元素

所以，这是一个非常优雅的解决方案

请参阅：

#include <iostream>
#include <list>
#include <array>
#include <numeric>

// The dimensions and size for our array
constexpr size_t NumberOfRows = 2U;
constexpr size_t NumberOfColumns = 10U;

int main() {

    // This is our std::list. 
    std::list<int> myList;

    // Fill the list with some demo values
    myList.resize(NumberOfRows * NumberOfColumns);
    std::iota(myList.begin(), myList.end(), 0);

    // -------------------------------------------------------------
    // This is the solution for a C++ std::list and a C++ std::array

    // Get an iterator to the begin of the list
    std::list<int>::iterator listIterator = myList.begin();

    // This is a 2 dimensional std::array with 2 rows and 10 columns
    std::array<std::array<int, NumberOfColumns>, NumberOfRows> myArray;

    // This is an iterator with which we can iterate over the rows in our target array. 
    // Since we ant to iterate from end to begin, we use an reverse iterator
    std::array<std::array<int, NumberOfColumns>, NumberOfRows>::reverse_iterator arrayRowIterator;

    // Iterate over the rows beginning from rbegin(), so, from the end
    for (arrayRowIterator = myArray.rbegin(); arrayRowIterator != myArray.rend(); ++arrayRowIterator) {

        // This is an iterator with which we can iterate over the columns in our target array. 
        // Since we want to iterate from end to begin, we use an reverse iterator
        std::array<int, NumberOfColumns>::reverse_iterator arrayColumnIterator;

        // Iterate over the columns beginning from rbegin(), so, from the end
        for (arrayColumnIterator = arrayRowIterator->rbegin(); arrayColumnIterator != arrayRowIterator->rend(); ++arrayColumnIterator) {
            // Assign the value
            *arrayColumnIterator = *listIterator;

            // Point to next value in the list
            ++listIterator;
        }
    }

    // Show debug output 
    for (size_t row = 0; row < NumberOfRows; ++row) {
        for (size_t column = 0; column < NumberOfColumns; ++column) {
            std::cout << myArray[row][column] << " ";
        }
        std::cout << "\n";
    }

    // --------------------------------------------------------------------------------------
    // If you use a C-Style array, what I fear then you can use the following simple approach

    // Define 2 dimensional C-Style array
    int myCStyleArray[NumberOfRows][NumberOfColumns];

    // Reset the iterator back to the list begin
    listIterator = myList.begin();

    // Iterate ove the C-Style array from end to begin
    for (int row = NumberOfRows - 1; row >= 0; --row) {
        for (int column = NumberOfColumns - 1; column >= 0; --column) {
            myCStyleArray[row][column] = *listIterator;
            ++listIterator;
        }
    }

    // Show debug output 
    for (size_t row = 0; row < NumberOfRows; ++row) {
        for (size_t column = 0; column < NumberOfColumns; ++column) {
            std::cout << myCStyleArray[row][column] << " ";
        }
        std::cout << "\n";
    }

    // -----------------------------------------------------------------------------------
    // This is the solution for a C++ std::list C-Style array, using pointers as iterators
    // If you check carefully, then you will se the similarity with pointers

    // Define 2 dimensional C-Style array
    int myCStyleArray2[NumberOfRows][NumberOfColumns];

    // Reset the iterator back to the list begin
    listIterator = myList.begin();

    // Define a pointer to an int[10]. Please note: In C++ you cannot use an int**
    int(*cStyleArrayRowIterator)[NumberOfColumns];

    // Iterate over the rows
    for (cStyleArrayRowIterator = myCStyleArray2 + NumberOfRows - 1; cStyleArrayRowIterator >= myCStyleArray2; --cStyleArrayRowIterator) {

        int* cStyleArrayColumnIterator;
        // Iterator over the columns
        for (cStyleArrayColumnIterator = *cStyleArrayRowIterator + NumberOfColumns - 1; cStyleArrayColumnIterator >= *cStyleArrayRowIterator; --cStyleArrayColumnIterator) {
            // Assign the values
            *cStyleArrayColumnIterator = *listIterator;
            ++listIterator;
        }
    }
    // Show debug output 
    for (size_t row = 0; row < NumberOfRows; ++row) {
        for (size_t column = 0; column < NumberOfColumns; ++column) {
            std::cout << myCStyleArray[row][column] << " ";
        }
        std::cout << "\n";
    }
    return 0;
}

#包括
#包括
#包括
#包括
//阵列的尺寸和大小
constexpr size_t NumberOfRows=2U；
constexpr size\u t NumberOfColumns=10U；
int main（）{
//这是我们的std：：列表。
std：：列表myList；
//用一些演示值填充列表
myList.resize（NumberOfRows*NumberOfColumns）；
std:：iota（myList.begin（），myList.end（），0）；
// -------------------------------------------------------------
//C++是一个C++ STD：：列表和C++ STD:：数组
//获取列表开头的迭代器
std:：list:：iterator listIterator=myList.begin（）；
//这是一个2维std:：数组，有2行10列
std：：数组myArray；
//这是一个迭代器，我们可以使用它对目标数组中的行进行迭代。
//因为我们需要从头迭代，所以我们使用反向迭代器
std:：array:：reverse_迭代器arrayRowIterator；
//迭代从rbegin（）开始的行，因此，从末尾开始
对于（arrayRowIterator=myArray.rbegin（）；arrayRowIterator！=myArray.rend（）；++arrayRowIterator）{
//这是一个迭代器，我们可以使用它对目标数组中的列进行迭代。
//因为我们想从头迭代，所以我们使用了一个反向迭代器
std:：array:：reverse_迭代器arrayColumnIterator；
//迭代从rbegin（）开始的列，因此，从
对于（arrayColumnIterator=arrayRowIterator->rbegin（）；arrayColumnIterator！=arrayRowIterator->rend（）；++arrayColumnIterator）{
//赋值
*arrayColumnIterator=*listIterator；
//指向列表中的下一个值
++列表迭代器；
}
}
//显示调试输出
对于（行大小=0；行数<行数；++行数）{
对于（大小\u t列=0；列STD:：P> > OK，从我理解的，你想把值从<代码> STD:：列表< /CUT>分配到2维数组。我希望你是指<代码> STD:：数组< /C> >，而不是C++中不应该使用的C样式数组。
但是，我担心你指的是C型数组
无论如何，我将向您展示3种解决方案

使用C++ <代码> STD:：数组< /C> >并用迭代器< /LI>做所有操作
使用C样式数组并使用索引运算符
使用C样式数组并使用指针，类似于迭代器

我们将从头到尾填充阵列
< C++ >迭代器，这是非常简单的，因为我们可以使用所谓的<代码> RealSythRealthAuth/Cuth>。如果用“代码> ReXORE（））//CODE初始化这个，那么它将指向最后一个元素。
所以，这是一个非常优雅的解决方案
请参阅：
#include <iostream>
#include <list>
#include <array>
#include <numeric>

// The dimensions and size for our array
constexpr size_t NumberOfRows = 2U;
constexpr size_t NumberOfColumns = 10U;

int main() {

    // This is our std::list. 
    std::list<int> myList;

    // Fill the list with some demo values
    myList.resize(NumberOfRows * NumberOfColumns);
    std::iota(myList.begin(), myList.end(), 0);

    // -------------------------------------------------------------
    // This is the solution for a C++ std::list and a C++ std::array

    // Get an iterator to the begin of the list
    std::list<int>::iterator listIterator = myList.begin();

    // This is a 2 dimensional std::array with 2 rows and 10 columns
    std::array<std::array<int, NumberOfColumns>, NumberOfRows> myArray;

    // This is an iterator with which we can iterate over the rows in our target array. 
    // Since we ant to iterate from end to begin, we use an reverse iterator
    std::array<std::array<int, NumberOfColumns>, NumberOfRows>::reverse_iterator arrayRowIterator;

    // Iterate over the rows beginning from rbegin(), so, from the end
    for (arrayRowIterator = myArray.rbegin(); arrayRowIterator != myArray.rend(); ++arrayRowIterator) {

        // This is an iterator with which we can iterate over the columns in our target array. 
        // Since we want to iterate from end to begin, we use an reverse iterator
        std::array<int, NumberOfColumns>::reverse_iterator arrayColumnIterator;

        // Iterate over the columns beginning from rbegin(), so, from the end
        for (arrayColumnIterator = arrayRowIterator->rbegin(); arrayColumnIterator != arrayRowIterator->rend(); ++arrayColumnIterator) {
            // Assign the value
            *arrayColumnIterator = *listIterator;

            // Point to next value in the list
            ++listIterator;
        }
    }

    // Show debug output 
    for (size_t row = 0; row < NumberOfRows; ++row) {
        for (size_t column = 0; column < NumberOfColumns; ++column) {
            std::cout << myArray[row][column] << " ";
        }
        std::cout << "\n";
    }

    // --------------------------------------------------------------------------------------
    // If you use a C-Style array, what I fear then you can use the following simple approach

    // Define 2 dimensional C-Style array
    int myCStyleArray[NumberOfRows][NumberOfColumns];

    // Reset the iterator back to the list begin
    listIterator = myList.begin();

    // Iterate ove the C-Style array from end to begin
    for (int row = NumberOfRows - 1; row >= 0; --row) {
        for (int column = NumberOfColumns - 1; column >= 0; --column) {
            myCStyleArray[row][column] = *listIterator;
            ++listIterator;
        }
    }

    // Show debug output 
    for (size_t row = 0; row < NumberOfRows; ++row) {
        for (size_t column = 0; column < NumberOfColumns; ++column) {
            std::cout << myCStyleArray[row][column] << " ";
        }
        std::cout << "\n";
    }

    // -----------------------------------------------------------------------------------
    // This is the solution for a C++ std::list C-Style array, using pointers as iterators
    // If you check carefully, then you will se the similarity with pointers

    // Define 2 dimensional C-Style array
    int myCStyleArray2[NumberOfRows][NumberOfColumns];

    // Reset the iterator back to the list begin
    listIterator = myList.begin();

    // Define a pointer to an int[10]. Please note: In C++ you cannot use an int**
    int(*cStyleArrayRowIterator)[NumberOfColumns];

    // Iterate over the rows
    for (cStyleArrayRowIterator = myCStyleArray2 + NumberOfRows - 1; cStyleArrayRowIterator >= myCStyleArray2; --cStyleArrayRowIterator) {

        int* cStyleArrayColumnIterator;
        // Iterator over the columns
        for (cStyleArrayColumnIterator = *cStyleArrayRowIterator + NumberOfColumns - 1; cStyleArrayColumnIterator >= *cStyleArrayRowIterator; --cStyleArrayColumnIterator) {
            // Assign the values
            *cStyleArrayColumnIterator = *listIterator;
            ++listIterator;
        }
    }
    // Show debug output 
    for (size_t row = 0; row < NumberOfRows; ++row) {
        for (size_t column = 0; column < NumberOfColumns; ++column) {
            std::cout << myCStyleArray[row][column] << " ";
        }
        std::cout << "\n";
    }
    return 0;
}

#包括
#包括
#包括
#包括
//阵列的尺寸和大小
constexpr size_t NumberOfRows=2U；
constexpr size\u t NumberOfColumns=10U；
int main（）{
//这是我们的std：：列表。
std：：列表myList；
//用一些演示值填充列表
myList.resize（NumberOfRows*NumberOfColumns）；
std:：iota（myList.begin（），myList.end（），0）；
// -------------------------------------------------------------
//C++是一个C++ STD：：列表和C++ STD:：数组
//获取列表开头的迭代器
std:：list:：iterator listIterator=myList.begin（）；
//这是一个2维std:：数组，有2行10列
std：：数组myArray；
//这是一个迭代器，我们可以使用它对目标数组中的行进行迭代。
//因为我们需要从头迭代，所以我们使用反向迭代器
std:：array:：reverse_迭代器arrayRowIterator；
//迭代从rbegin（）开始的行，因此，从末尾开始
对于（arrayRowIterator=myArray.rbegin（）；arrayRowIterator！=myArray.rend（）；++arrayRowIterator）{
//这是一个迭代器，我们可以使用它对目标数组中的列进行迭代。
//因为我们想从头迭代，所以我们使用了一个反向迭代器
std:：array:：reverse_迭代器arrayColumnIterator；
//迭代从rbegin（）开始的列，因此，从
对于（arrayColumnIterator=arrayRowIterator->rbegin（）；arrayColumnIterator！=arrayRowIterator->rend（）；++arrayColumnIterator）{
//赋值
*arrayColumnIterator=*listIterator；
//指向列表中的下一个值
++列表迭代器；
}
}
//显示调试输出
法罗群岛