C++ 如何创建二维矩阵c+的水平镜像逆矩阵+；？

例如，如果输入为：

21 26 31 36
22 27 32 37
23 28 33 38
24 29 34 39
25 30 35 40

输出应为：

25 30 35 40
24 29 34 39
23 28 33 38
22 27 32 37
21 26 31 36

所有行交换到中间行

第一行应与最后一行交换，第二行应与前一行交换，以此类推

这是我的代码：

int A[100][100] = { 0 };
int n, m;
std::cin >> n >> m;


for (int k = 0, j = n - 1; k < j; k++, --j)
     std::swap(A[k], A[j]);

inta[100][100]={0}；
int n，m；
标准：cin>>n>>m；
对于（int k=0，j=n-1；k

行数（n），列数（m），对于n，m<100

---

它显示了与以前相同的矩阵。

您可以使用标准算法

std:：swap_ranges

或通过“手动”写入循环来交换二维数组

这是一个演示程序

#include <iostream>
#include <iterator>
#include <algorithm>

int main() 
{
    const size_t M = 5, N = 4;
    int a[M][N] = 
    {
        { 21, 26, 31, 36 },
        { 22, 27, 32, 37 },
        { 23, 28, 33, 38 },
        { 24, 29, 34, 39 },
        { 25, 30, 35, 40 }
    };

    for ( const auto &row : a )
    {
        for ( const auto &item : row )
        {
            std::cout << item << ' ';
        }
        std::cout << '\n';
    }
    std::cout << '\n';

    std::swap_ranges( std::begin( a ), std::next( std::begin( a ), M / 2 ), 
                      std::rbegin( a ) );

    for ( const auto &row : a )
    {
        for ( const auto &item : row )
        {
            std::cout << item << ' ';
        }
        std::cout << '\n';
    }
    std::cout << '\n';

    for ( std::size_t i = 0; i < N / 2; i++ )
    {
        std::swap( a[i], a[M - i - 1] );
    }

    for ( const auto &row : a )
    {
        for ( const auto &item : row )
        {
            std::cout << item << ' ';
        }
        std::cout << '\n';
    }
    std::cout << '\n';

    return 0;
}

请注意，可变长度数组不是标准C++特性。这意味着数组的大小在编译时是已知的。如果希望由用户输入尺寸，则使用标准类模板

std:：vector

---

如果已经定义了一个数组，其大小有一些最大值，并且用户可以指定其子数组，则该数组应至少初始化为零。您可以使用以下方法交换二维数组：

---

如何定义一个概念？如何验证矩阵是否已翻转？请提供一个示例，如果

a

是

std:：vector

，则只需调用

std:：reverse

。给定数组--

std:：reverse（&a[0]，&a[5]），它就是一个
int[]
--不需要循环。
21 26 31 36 
22 27 32 37 
23 28 33 38 
24 29 34 39 
25 30 35 40 

25 30 35 40 
24 29 34 39 
23 28 33 38 
22 27 32 37 
21 26 31 36 

21 26 31 36 
22 27 32 37 
23 28 33 38 
24 29 34 39 
25 30 35 40 

#include <algorithm>
#include <iostream>

int main()
{
    int A[100][100] = { {21, 26, 31, 36},
                        {22, 27, 32, 37},
                        {23, 28, 33, 38},
                        {24, 29, 34, 39},
                        {25, 30, 35, 40} };

    std::reverse(&A[0], &A[5]);  // Starting and ending ranges are &A[0] and &A[5]

    // Output results
    for (int i = 0; i < 5; ++i)
    {
        for (int j = 0; j < 4; ++j)
            std::cout << A[i][j] << " ";
        std::cout << "\n";
    }
}

25 30 35 40 
24 29 34 39 
23 28 33 38 
22 27 32 37 
21 26 31 36