如何在C++中删除二维数组中的列 我在C++中有一个基本的2D数组。我想删除一个特定的列，并将下一列放在它的位置。我的数组是 名称[]标记[] FNAME[]注册号[] Name和FNAME位于第一个2d阵列字符串中，而Tmarks和reg位于第二个2d阵列字符串中

我已经尝试了StackOverflow的解决方案，但没有成功

#include <iostream>
using namespace std;
#define ROW 2
#define COL 70
void input(string data[][COL], int moredata[][COL], int n)
{
    for (int i = 0; i < ROW; i++)
    {
    for (int j = 0; j < n; j++)
    {
        if (i == 0)
        {
            cout << " Name of Student #  : " << j + 1 << endl;
            cin >> data[i][j];
            cout << "Total Marks out of 600 of student #  " << j + 1 <<
            endl;            
            cin >> moredata[i][j];
        }
        if (i == 1)
        {
            cout << " Father Name of Student # " << j + 1 << endl;
            cin >> data[i][j];
            cout << "Reg # of student # " << j + 1 << endl;
            cin >> moredata[i][j];
        }
     }
     }
}
int main()
{
int n;
string data[ROW][COL] = {};
int moredata[ROW][COL] = {};
cout << "NO of Students: ";
do
{
    cin >> n;
} while (n > 70 || n < 0);
input(data, moredata, n); //input function already created.

---

现在，我想创建一个函数来删除单个列。

不可能删除数组的元素。数组的大小是恒定的。它从生命的开始一直保持不变，直到被摧毁。C++提供了一个可调整的动态数组数据结构，名为STD:：vector。 您可以做的是将连续元素的内容复制到它们前面的同级元素上。这实际上有一个标准算法：std:：rotate。但是，“旋转”会保留所有元素的值；写在上面的一个旋转到末尾。这不一定是您所需要的，所以作为一个小优化，您可以编写自己的算法，而不这样做

---

对于多维数组，需要对每一行重复此算法。

无法删除数组的元素。数组的大小是恒定的。它从生命的开始一直保持不变，直到被摧毁。C++提供了一个可调整的动态数组数据结构，名为STD:：vector。 您可以做的是将连续元素的内容复制到它们前面的同级元素上。这实际上有一个标准算法：std:：rotate。但是，“旋转”会保留所有元素的值；写在上面的一个旋转到末尾。这不一定是您所需要的，所以作为一个小优化，您可以编写自己的算法，而不这样做

---

对于多维数组，需要对每一行重复此算法。

不能从数组中删除列。但您可以将列的所有元素向左移动以填充已删除的列，并保留数组的实际列数

这是一个演示程序。在程序中，变量n存储二维数组的实际列数

#include <iostream>
#include <string>
#include <type_traits>
#include <iterator>
#include <algorithm>

template <typename T>
bool remove_column( T &a, size_t n, size_t pos )
{
    const size_t N = 
        std::extent<typename std::remove_reference<decltype( a )>::type, 1>::value;

    bool success = n <= N && pos < n;

    if ( success )
    {
        for ( auto &row : a )
        {
            std::copy( std::next( std::begin( row ), pos + 1 ), 
                       std::next( std::begin( row ), n ),
                       std::next( std::begin( row ), pos ) );
        }
    }

    return success;
}

int main() 
{
    const size_t M = 4;
    const size_t N = 5;
    std::string a[M][N] =
    {
        { "A0", "B0", "C0", "D0", "E0" },
        { "A1", "B1", "C1", "D1", "E1" },
        { "A2", "B2", "C2", "D2", "E2" },
        { "A3", "B3", "C3", "D3", "E3" },
    };

    size_t n = N;

    for ( const auto &row : a )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            std::cout << row[i] << ' ';
        }
        std::cout << '\n';
    }

    std::cout << '\n';

    if ( remove_column( a, n, 0 ) ) --n;

    for ( const auto &row : a )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            std::cout << row[i] << ' ';
        }
        std::cout << '\n';
    }

    std::cout << '\n';

    if ( remove_column( a, n, n - 1 ) ) --n;

    for ( const auto &row : a )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            std::cout << row[i] << ' ';
        }
        std::cout << '\n';
    }

    std::cout << '\n';

    if ( remove_column( a, n, 1 ) ) --n;

    for ( const auto &row : a )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            std::cout << row[i] << ' ';
        }
        std::cout << '\n';
    }

    std::cout << '\n';

    return 0;
}

或者，可以用以下更简单的方法定义函数

template <typename T, size_t M, size_t N>
bool remove_column( T ( &a )[M][N], size_t n, size_t pos )
{
    bool success = n <= N && pos < n;

    if ( success )
    {
        for ( auto &row : a )
        {
            std::copy( std::next( std::begin( row ), pos + 1 ), 
                       std::next( std::begin( row ), n ),
                       std::next( std::begin( row ), pos ) );
        }
    }

    return success;
}

在这种情况下，标头是冗余的

---

也可以使用std:：move算法代替std:：copy算法。

不能从数组中删除列。但您可以将列的所有元素向左移动以填充已删除的列，并保留数组的实际列数

这是一个演示程序。在程序中，变量n存储二维数组的实际列数

#include <iostream>
#include <string>
#include <type_traits>
#include <iterator>
#include <algorithm>

template <typename T>
bool remove_column( T &a, size_t n, size_t pos )
{
    const size_t N = 
        std::extent<typename std::remove_reference<decltype( a )>::type, 1>::value;

    bool success = n <= N && pos < n;

    if ( success )
    {
        for ( auto &row : a )
        {
            std::copy( std::next( std::begin( row ), pos + 1 ), 
                       std::next( std::begin( row ), n ),
                       std::next( std::begin( row ), pos ) );
        }
    }

    return success;
}

int main() 
{
    const size_t M = 4;
    const size_t N = 5;
    std::string a[M][N] =
    {
        { "A0", "B0", "C0", "D0", "E0" },
        { "A1", "B1", "C1", "D1", "E1" },
        { "A2", "B2", "C2", "D2", "E2" },
        { "A3", "B3", "C3", "D3", "E3" },
    };

    size_t n = N;

    for ( const auto &row : a )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            std::cout << row[i] << ' ';
        }
        std::cout << '\n';
    }

    std::cout << '\n';

    if ( remove_column( a, n, 0 ) ) --n;

    for ( const auto &row : a )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            std::cout << row[i] << ' ';
        }
        std::cout << '\n';
    }

    std::cout << '\n';

    if ( remove_column( a, n, n - 1 ) ) --n;

    for ( const auto &row : a )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            std::cout << row[i] << ' ';
        }
        std::cout << '\n';
    }

    std::cout << '\n';

    if ( remove_column( a, n, 1 ) ) --n;

    for ( const auto &row : a )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            std::cout << row[i] << ' ';
        }
        std::cout << '\n';
    }

    std::cout << '\n';

    return 0;
}

或者，可以用以下更简单的方法定义函数

template <typename T, size_t M, size_t N>
bool remove_column( T ( &a )[M][N], size_t n, size_t pos )
{
    bool success = n <= N && pos < n;

    if ( success )
    {
        for ( auto &row : a )
        {
            std::copy( std::next( std::begin( row ), pos + 1 ), 
                       std::next( std::begin( row ), n ),
                       std::next( std::begin( row ), pos ) );
        }
    }

    return success;
}

在这种情况下，标头是冗余的

---

也可以使用std:：move算法代替std:：copy算法。

考虑一下基本情况，您希望从数组中删除一个元素。因为您的表是一个数组数组，所以只需对每一行重复此基本任务。你也可以发布你已经尝试过的代码吗？如果不发布代码和错误，很难知道您遇到的问题是什么。考虑一下基本情况，您希望从数组中删除一个元素。因为您的表是一个数组数组，所以只需对每一行重复此基本任务。你也可以发布你已经尝试过的代码吗？如果你不发布代码和错误，你很难知道你的问题是什么。