КАК ВНУТРИ СОЕДИНИТЬ правильное ЗНАЧЕНИЕ из 2 значений в таблице, где 1 является правильным

Фиксированный размер

1. Передача по ссылке

template 
void process_2d_array_template(int (&array)[rows][cols])
{
    std::cout << __func__ << std::endl;
    for (size_t i = 0; i < rows; ++i)
    {
        std::cout << i << ": ";
        for (size_t j = 0; j < cols; ++j)
            std::cout << array[i][j] << '\t';
        std::cout << std::endl;
    }
}

В C ++ передача массива по ссылке без потери информации о размерах, вероятно, является самой безопасной, так как не нужно беспокоиться о том, что вызывающий абонент передает неправильное измерение (флаги компилятора при несоответствии). Однако это невозможно с динамическими (freestore) массивами; он работает только для автоматических ( обычно стек-живых ) массивов, т. е. размерность должна быть известна во время компиляции.

2. Pass by pointer

void process_2d_array_pointer(int (*array)[5][10])
{
    std::cout << __func__ << std::endl;
    for (size_t i = 0; i < 5; ++i)
    {
        std::cout << i << ": ";
        for (size_t j = 0; j < 10; ++j)
            std::cout << (*array)[i][j] << '\t';
        std::cout << std::endl;
    }    
}

С-эквивалент предыдущего метода передает массив по указателю. Это не следует путать с передачей по разлагаемому типу указателя массива (3), который является распространенным, популярным методом, хотя и менее безопасным, чем этот, но более гибким. Как и (1), используйте этот метод, когда все размеры массива фиксированы и известны во время компиляции. Обратите внимание, что при вызове функции адрес массива должен быть передан process_2d_array_pointer(&a), а не адрес первого элемента путем распада process_2d_array_pointer(a).

Размер переменной

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

Следует помнить, что нет такой вещи, как передача массива непосредственно функции в C [в то время как в C ++ они могут быть переданы как ссылка (1)]; (2) передает указатель на массив, а не сам массив. Всегда передавать массив as-is становится операцией копирования-указателя, которая облегчается природой массива для разложения в указатель .

3. Pass by (value) указатель на затухающий тип

// int array[][10] is just fancy notation for the same thing
void process_2d_array(int (*array)[10], size_t rows)
{
    std::cout << __func__ << std::endl;
    for (size_t i = 0; i < rows; ++i)
    {
        std::cout << i << ": ";
        for (size_t j = 0; j < 10; ++j)
            std::cout << array[i][j] << '\t';
        std::cout << std::endl;
    }
}

Хотя разрешено int array[][10], я бы не рекомендовал его над указанным выше синтаксисом, поскольку приведенный выше синтаксис дает понять, что идентификатор array является единственным указателем на массив из 10 целых чисел, в то время как этот синтаксис выглядит , как будто это 2D-массив, но является тем же самым указателем на массив из 10 целых чисел. Здесь мы знаем количество элементов в одной строке (т. Е. Размер столбца, здесь 10), но количество строк неизвестно и, следовательно, должно быть передано в качестве аргумента. В этом случае есть определенная безопасность, поскольку компилятор может указывать, когда передается указатель на массив со вторым измерением, не равным 10. Первое измерение является изменяющейся частью и может быть опущено. См. здесь обоснование о том, почему разрешено только первое измерение.

4. Пропустить указатель на указатель

// int *array[10] is just fancy notation for the same thing
void process_pointer_2_pointer(int **array, size_t rows, size_t cols)
{
    std::cout << __func__ << std::endl;
    for (size_t i = 0; i < rows; ++i)
    {
        std::cout << i << ": ";
        for (size_t j = 0; j < cols; ++j)
            std::cout << array[i][j] << '\t';
        std::cout << std::endl;
    }
}

Опять есть альтернативный синтаксис int *array[10], который совпадает с int **array. В этом синтаксисе [10] игнорируется, поскольку он распадается на указатель, тем самым становясь int **array. Возможно, это всего лишь сигнал вызывающему, что переданный массив должен иметь не менее 10 столбцов, даже если требуется подсчет строк. В любом случае компилятор не указывает на какие-либо нарушения длины и размера (он проверяет, является ли переданный тип указателем на указатель), поэтому для определения значения параметра строки и столбца требуется значение параметра

Примечание: (4) является наименее безопасным вариантом , поскольку он вряд ли имеет проверку типа и наиболее неудобен. Нельзя законно передать 2D-массив этой функции; C-FAQ осуждает обычное обходное решение для выполнения int x[5][10]; process_pointer_2_pointer((int**)&x[0][0], 5, 10);, поскольку оно может потенциально привести к неопределенному поведению из-за сглаживания массива. Правильный способ передачи массива в этом методе приводит нас к неудобной части, то есть нам нужен дополнительный (суррогатный) массив указателей, каждый из которых указывает на соответствующую строку фактического, подлежащего передаче массива; этот суррогат затем передается функции (см. ниже); все это для того, чтобы выполнить ту же работу, что и вышеупомянутые методы, которые более безопасны, чище и, возможно, быстрее.

Вот программа драйвера для проверки вышеперечисленных функций:

#include 

// copy above functions here

int main()
{
    int a[5][10] = { { } };
    process_2d_array_template(a);
    process_2d_array_pointer(&a);    // <-- notice the unusual usage of addressof (&) operator on an array
    process_2d_array(a, 5);
    // works since a's first dimension decays into a pointer thereby becoming int (*)[10]

    int *b[5];  // surrogate
    for (size_t i = 0; i < 5; ++i)
    {
        b[i] = a[i];
    }
    // another popular way to define b: here the 2D arrays dims may be non-const, runtime var
    // int **b = new int*[5];
    // for (size_t i = 0; i < 5; ++i) b[i] = new int[10];
    process_pointer_2_pointer(b, 5, 10);
    // process_2d_array(b, 5);
    // doesn't work since b's first dimension decays into a pointer thereby becoming int**
}