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

[RUSt88]

не могу понять, в чем проблема
сама задача такая: работа с матрицей при помощи указателей
я сделал так: создал указатель на одномерный массив, элементы к-рого являются указателями на одномерный массив, т.е. получили как бы массив указателей
код абсолютно работающий

	int **pmat; int *pv; int *pvn, *max;  // объявление указателей на массивы
	int R; // размерность матрицы и векторов
	cout<<"Vvedite razmernost' matricy: "<<endl; // предлагаем ввести пользователю размерность
	cin>>R; // присваиваем переменной R размерность
	pmat = new int *[R];  // создаём массив указателей
	max = new int[R];   //указатель на массив элементов
	for (int i = 0; i < R; i++)
	{
		*(max + i) = 0; //обнуляем массив, нужен для нахождения максимального элемента строки матрицы
	}
	for (int i = 0; i < R; i++)
	{
		*(pmat + i) = new int[R]; //создаём массив указателей
	}
	pv = new int[R]; pvn = new int[R];  //вектор, указанный пользователем, и получившийся в результате умножения новый вектор
	randomize(); //чтобы числа в функции random не повторялись
	for (int i = 0; i < R; i++)  // цикл по строкам
	{
		for (int j = 0; j < R; j++) //цикл по столбцам
		{
			*(*(pmat + i) + j) = random(9); //не предлагаем ввести пользователю элементы матрицы, а заполняем случайными числами 0..9
			if (*(*(pmat + i) + j) > *(max + i))
			{
				*(max + i) = *(*(pmat + i) + j); //находим максимальный элемент строки матрицы
			}
		}
		*(pv + i) = random(9);
		*(pvn + i) = *(pv + i) * *(max + i);
		cout<<*(pvn + i)<<" ";
	}
	delete[] pmat, pv, pvn, max; //удаляем объекты

ПОЧЕМУ вместо *(pmat + i) (и похожее в коде) НЕЛЬЗЯ писать pmat++ ??? Ведь это же, в принципе, одно и то же.

Выдаёт ошибку, в пошаговой отладке видишь как со второго элемента массива pmat указатели идут как NULL.
Я знаю, что вместо *(pmat + i) можно писать pmat[i], но весь вопрос в том, что тогда теряется скорость (читал, как преобразуются эти команды, самая короткая, это pmat++)
IDE - Borland C++ 2009

[_Ч_]

Я знаю, что вместо *(pmat + i) можно писать pmat[i], но весь вопрос в том, что тогда теряется скорость...

Где это вы такое прочитали? это компилится в одно и то же:

int* p = 0;

//----------------------------------------

int i = p[5];
00412FF8 mov eax,dword ptr [p]
00412FFB mov ecx,dword ptr [eax+14h]
00412FFE mov dword ptr [i],ecx

//----------------------------------------

int j = *(p + 5);
00413001 mov eax,dword ptr [p]
00413004 mov ecx,dword ptr [eax+14h]
00413007 mov dword ptr [j],ecx

//----------------------------------------

[RUSt88]

*(pmat + i) и pmat[i] компилится в одно и то же, это да, но pmat++ выполняется быстрее, т.к. не происходит поиска адреса по индексу, а сразу перескакивает на след. адрес, это актуально в цикле

for (int i = 0; i < R; i++)
	{
		*(pmat + i) = new int[R]; //создаём массив указателей
	}

ПОЧЕМУ вместо *(pmat + i) (и похожее в коде) НЕЛЬЗЯ писать pmat++ (переход на след адрес и запись по этому адресу указателя)???
ошибка в том, что тогда указатели в массиве будут NULL

[_Ч_]

pmat + 1 - эквивалентно pmat++
pmat + i - не эквивалентно pmat++ (при i > 1)
это вроде бы очевидно.

хотите использовать постинкремент, вот вам ваш переписанный цикл:

 max = new int[R];

 // было
 for (int i = 0; i < R; i++)
   {
     *(max + i) = 0;
   }

 // стало
 for (int* p = max, end = max + R; p != end; p++)
   {
     *p = 0;
   }

[/CODE]

[RUSt88]

_Ч_ здесь вопрос не в увеличении значения, а в переходе указателя на первый элемент массива на след адрес, т.е. на адрес 2-ого элемент массива и т.д.
Когда мы инкрементируем указатель, он переходит на след адрес на определенное число байт (int - это 4 байта, знач инкремент указателя перепрыгнет на адрес через 4 байта)
Я же не пишу pmat + i, я пишу *(pmat + i) - разные вещи

[RUSt88]

*(pmat + i) - каждый раз переход на след элемент массива, т.е. на след адрес(!!!)

[_Ч_]

что-то мы о разных вещах говорим.
ваш вопрос непонятен. попробую ответить на тот вопрос который был задан.
Вопрос:
ПОЧЕМУ вместо *(pmat + i) (и похожее в коде) НЕЛЬЗЯ писать pmat++ ???

Ответ:
Потому что это не одно и то же.
pmat в вашем случае это указатель на укажатель на int (int**)
предположим что в с++ есть оператор typeof(expr).
typeof(*(pmat + i)) == int*;
typeof(pmat++) == int**;
int* != int**

Если вы имели в виду что-то другое, то спросите яснее. А то я не понимаю что вы не понимаете ))

[RUSt88]

хорошо, прямой вопрос

*(pmat + i) нельзя ли заменить это выражение инкрементом (++) ?

например,
pmat++ (ошибка компиляции (невозможно int** в int*)), или *pmat++ (ошибка выполнения (указатели NULL) (НЕ ПОНИМАЮ ПОЧЕМУ???), или по другому

используя (в данном случае!) pmat[i] (или *(pmat + i), равнозначно), теряется смысл использования указателей, нет выигрыша в скорости (а ради этого вся дискуссия, не надо мне предлагать ассемблер)

разберем всё по порядку (поправьте меня, если я ошибаюсь)
pmat[i] - медленный код, т.к. происходит поиск адреса по индексу, к-рый постоянно вычисляется
*(pmat + i) - равнозначно предыдущему коду
pmat++ (или *pmat++ ?) - быстрый код, ничего не вычисляется, происходит переход на адрес следующего элемента (или я ошибаюсь?)

или всё это неправильно, тут можно только pmat[i] и баста?

а как же тогда инкремент указателя? Не просто так же его сделали
сейчас еще читаю лит-ру по этому вопросу, но какая у меня есть, там крайне скудно описан этот вопрос

[_Ч_]

*(pmat + i) нельзя ли заменить это выражение инкрементом (++) ?
на этот вопрос я уже ответил постом выше. прочитайте еще раз.


или всё это неправильно, тут можно только pmat[i] и баста?
На этот вопрос уже тоже есть ответ выше. Посмотрите как был переписан цикл для использования только постинкремента.

[Viral]

pmat++ - увеличение значения первого элемента массива на 1 , а *(pmat+1) переход на следующий элемент массива