Как правильно передавать указатель или ссылку на динамический массив в функцию?

Question

[Vadim kyklaed]

Добрый день! пытаюсь разобраться что лучше и как передавать ?
например у меня есть вот такой код : - в нем я передаю массив одномерный по ссылке ?
как правильно передать его по указателю ? я столкнулся при передачи по указателю что не понимаю где и что нужно разыменовывать например в этом кусочке кода !
следующий вопрос как передать тогда двумерный массив по ссылке и по указателю и как к ним обращаться ?

for (int i = 0; i < N; i++) {
      for (int j = N - 1; j > i; j--) {
	        if (mass[j - 1] > mass[j]) {
	           	T3 temp = mass[j];
	           	mass[j] = mass[j - 1];
	            	 mass[j - 1] = temp;

template<typename T3,typename T4>
void Bubble( T4 &mass,T3 N){
	for ( int i =0;i<N;i++){
		cout<<mass[i]<<"\n";
	}
	
	for (int i = 0; i < N; i++) {
	    	for (int j = N - 1; j > i; j--) {
	        	if (mass[j - 1] > mass[j]) {
	           		T3 temp = mass[j];
	           		mass[j] = mass[j - 1];
	            	        mass[j - 1] = temp;
	        	}	
	    	}	
	}				
}

int main(){
	int n;
	int m;
	cout<<"n= ";
	cin>>n;
	cout<<endl;;
	int *mass = new int [n];
	for(int i=0;i<n;i++){
		cout<<"m = ";
		cin>>m;
		cout<<endl;
		
		mass[i]=m;
	}
	cout<<"&mass = "<<&mass<<endl;
	Bubble(mass,n);
	cout<<"PRINT"<<endl;
	for ( int i =0;i<n;i++){
		cout<<mass[i]<<"\n";
	}
	return 0;
}

Answer 1

[devalone]

Зачем усложнять? Динамический массив, как у тебя - это указатель на массив указателей, вот его и передавай. А лучше всего конечно vector.

#include <iostream>
#include <vector>

const size_t SIZE = 10;

// const нужен для защиты данных от модификации
template <typename T>
void print1DArray(const T* array, const size_t size)
{
    for (size_t i = 0; i < size; ++i) {
        std::cout << array[i] << " ";
        // благодаря const следующая строка не компилируется
        // array[i] = 55;
    }
    std::cout << std::endl;
    std::cout << std::endl;
}

template <typename T>
void print2DArray(const T* const* array, const size_t rows, const size_t columns)
{
    for (size_t y = 0; y < rows; ++y) {
        for (size_t x = 0; x < columns; ++x) {
            std::cout << array[y][x] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
    std::cout << std::endl;
}

template <typename T>
void printVector(const std::vector<T>& vector)
{
    for (const auto& item : vector) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
    std::cout << std::endl;
}

int main()
{
    int* array1D = new int[SIZE];
    array1D[0] = 99;
    array1D[1] = 55;

    print1DArray(array1D, SIZE);

    delete[] array1D;

    int** array2D = new int*[SIZE];
    for (size_t i = 0; i < SIZE; ++i) {
        array2D[i] = new int[SIZE * 2];
        for (size_t j = 0; j < SIZE * 2; ++j) {
            array2D[i][j] = i + j;
        }
    }

    print2DArray(array2D, SIZE, SIZE * 2);

    for (size_t i = 0; i < SIZE; ++i) {
        delete[] array2D[i];
    }

    delete[] array2D;

    std::vector<int> vector(SIZE, 14);

    printVector(vector);

    return 0;
}

Comments

[Vadim kyklaed]

так вот например я передаю
int *mass = new int [n]; - указатель на массив указателей
передача в функцию не по ссылке ?

int** array2D = new int*[SIZE] - вот это что значит int*[SIZE] - еще разыменование ?

мне не понятно где то пишут что когда передаешь указатель в функцию ты ты должен отдать ссылку на объект

[devalone]

Vadim kyklaed,

int** array2D = new int*[SIZE] - вот это что значит int*[SIZE] - еще разыменование ?

нет, массив указателей на int

мне не понятно где то пишут что когда передаешь указатель в функцию ты ты должен отдать ссылку на объект

вот тут не понял, что имеется в виду

[res2001]

̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻ ҉, Зачем делать из обычного двумерного массива массив указателей?
Почему бы не сделать вот так:
int* array2D = new int[SIZE * SIZE];
Это вариант для квадратной матрицы [SIZE; SIZE].
Правда в этом случае не прокатывает обращение по индексу для второй размерности. Но это не трудно обходится переходом к одномерному массиву:

void function(int * array2d, size_t N, size_t M)
{
  for(size_t i = 0; i < N; ++i)
  {
     for(size_t j = 0; j < M; ++j)
     {
         array2d[j] = i * j;
     }
     array2d += M;
  }
}

Этот вариант для понимания работы адресной арифметики.
Можно еще немного оптимизировать этот цикл:

void function(int * array2d, size_t N, size_t M)
{
  for(size_t i = 0; i < N; ++i)
  {
     for(size_t j = 0; j < M; ++j, ++array2d)
     {
         *array2d = i * j;
     }
  }
}

[Vadim kyklaed]

̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻ ҉,
я окончательно запутался.
int** array2D = new int*[SIZE];
for (size_t i = 0; i < SIZE; ++i) {
array2D[i] = new int[SIZE * 2];
for (size_t j = 0; j < SIZE * 2; ++j) {
array2D[i][j] = i + j;

int** array2D - указатель на указатель на int ?
new int*[SIZE] - массив указателей на int ?

доступ к ему мы получаем ччерез int** array2D ?

а дальше по коду я не понимаю зачем тут array2D[i] = new int[SIZE * 2];

[devalone]

res2001,

Зачем делать из обычного двумерного массива массив указателей?
Почему бы не сделать вот так:
int* array2D = new int[SIZE * SIZE];

Естественно так лучше, т.к. данные лежат одним куском в памяти, а ещё лучше std::vector такого размера, но в учебных примерах обычно дают массив указателей, я думал ты про него.

[devalone]

если тебе нужно хранить данные в памяти последовательно, то так:

#include <iostream>
#include <vector>

template <typename T>
void print2DFlatArray(const T* array, const size_t rows, const size_t columns)
{
    for (size_t y = 0; y < rows; ++y) {
        for (size_t x = 0; x < columns; ++x) {
            std::cout << array[y * columns + x] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
    std::cout << std::endl;
}
int main()
{
    const size_t SIZE = 10;

    int* array = new int[SIZE * SIZE];
    array[0] = 10;
    array[SIZE + 1] = 11;
    array[2 * SIZE + 2] = 12;

    print2DFlatArray(array, SIZE, SIZE);

    return 0;
}

̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻̻ ҉,
или так:

#include <iostream>
#include <vector>

template <typename T>
void print2DFlatArray(const T* array, const size_t rows, const size_t columns)
{
    for (size_t y = 0; y < rows; ++y) {
        for (size_t x = 0; x < columns; ++x, ++array) {
            std::cout << *array << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
    std::cout << std::endl;
}
int main()
{
    const size_t SIZE = 10;

    int* array = new int[SIZE * SIZE];
    array[0] = 10;
    array[SIZE + 1] = 11;
    array[2 * SIZE + 2] = 12;

    print2DFlatArray(array, SIZE, SIZE);

    return 0;
}

[devalone]

Vadim kyklaed,

int** array2D - указатель на указатель на int ?

да

new int*[SIZE] - массив указателей на int ?

ага

а дальше по коду я не понимаю зачем тут array2D[i] = new int[SIZE * 2];

чтоб создать строки