привести пример выражения где int a[3][4] использовался бы как int**. 

Я такой пример привел, он вас не устроил? Например так:


Добавлено через 5 минут и 52 секунды
Или так:

хм... в какой строке массив или его имя используется именно как int**? Правда не вижу

Как тогда вы эту строку расцениваете? Как работу с целым числом?

Добавлено через 1 минуту и 57 секунд
Объясните, какие действия вы хотите сделать с двойным указателем? Приведите пример работы с двойным указателем, который бы вы хотели увидеть?

ну совсем не как int**, ведь если 2 раза разыменовать и в результате получить int еще не означает, что то, что разыменовывается имеет тип int**. Я привел пример когда **ppa выдает int, но ppa не является int** 

http://forum.vingrad.ru/index.php?showtopi...t&p=1114163
 
ведь получаемый результат выражения (я имею в виду адрес) a + 1 разный в зависимости от того какого типа a. Ведь если a типа int** , то смещение будет 4*1 байта, а если a[2][2] , то смещение будет sizeof(int[2])*1. 
и в твоем примере с циклом *a возвращает массив int[4] , а потом к нему применяется смещение 0 и разыменовывание дает int

Добавлено через 3 минуты и 9 секунд

мне неизвестны такие примеры, которые компиллировались бы, либо компиллировались и работали бы. Поэтому я и утверждаю, что ни массив int a[2][2] ни его имя не являются int**. Те кто это утверждают, видимо знают такие действия и примеры

С такой логикой можно любой пример оспорить.

К этому коду это суждение не относится. Разыменовывается без всяких приведений и искусственных преобразований (переопределений) и выдает именно то значение, которое  ожидалось.




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


Теперь выдаем 2-ю строку массива (или столбец - как кому удобнее)
Что теперь с указательной арифметикой не устроит?

Добавлено через 6 минут и 58 секунд


Я привел вам 2 работающих примера, когда имя массива можно использовать в качестве указателя. Я никогда не утверждал, что имя массива является указателем - так как он имеет тип int[3][4] - это легко увидеть использовав typeid(...).name()

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

Если бы вы не увидели предыдущего текста, как бы вы расценили эту строку:
printf("%lf\t",*((*aa+1)+i));

У вас бы спросили какого типа aa? Что бы вы ответили? По выражению - это работа с двойным указателем и никак иначе. Строка одинаково выглядит и если бы aa была бы объявлена как ** и как двойной массив.

это выглядит как работа с двойным указателем, но это не является работой с двойным указателем, потому что

 и aa в твоем примере используется как указатель на массив , а не как double**

т.е. согласно вашей логике, указатель на конкретный тип данных и указатель на массив из таких данных отличаются?

char *s; - Это указатель именно на переменную типа char (т.е. на 1 символ) или на массив таких символов? Ответьте мне, пожалуйста.

Далее:

char **s; - Это указатель на указатель на символ или указатель на массив указателей на символ?

Это вообще указатель на массив указателей на тип char
и другое дело какие адреса взяты указателями

А просто как указатель на указатель его нельзя использовать? Можно.

Тогда объяснитем мне смысл этой фразы:



Как тогда использовать double**? Как указатель на массив не подходит, а как нужно?

да. массив и указатель это разные типы. Передай sizeof массив и указатель , который указывает на его первый элемент. Получишь разные результаты. tipeid выдаст разное.  Физически - это адрес, но работа с ним и результат зависит от того как объявлено.

это указатель на символ. Массив символов при передаче в функцию передается как char *s.

Строковый литерал "11" имеет тип char[3].

Я понимаю, что соблазн представлять массив как указатель достаточно велика, но если следовать логике, что  в строке
for (i=0;i<4;i++) printf("%d\t",*(*a)+i); a - используется в виде int** , то почему в параметрах функции двумерный массив не преобразуется в int**.
Весь фокус не в том насколько велика разница между массивом и указателем, а в том что слишком большая разница между указателем на массив и указателем на указатель.

P.S.



А я как написал? По-другому?



Если конечно не придираться, что я char назвал символом - ну лень мне было язык переключать    

допустимо только для совместимости со старым кодом.
так ведь недопустимо


Добавлено @ 18:10

это указатель на указатель на char или на символ, в данном случае понятно.


Это сообщение отредактировал(а) Fazil6 - 27.4.2007, 18:11

Потому, что он таковым не является.

Тут примерно такая же разница как между адресом функции и адресом метода класса.
Если массив определяется статически - то для вычисления смещения необходимо знать размерность этого массива. А в голом указателе такой информации нет.

Если вы создаете массив динамически и передаете его в функцию, то что должна знать функция? Это адрес собственно массива и его размерности. Для чего? Чтобы правильно вычислить местоположение конкретного элемента.

Когда массив определен явно, он выделяется прямым куском в памяти и размерности его известны. Именно поэтому он получает тип int [3][4], а не int** - т.е. в этот тип уже явно включены размерности.

Если он создается динамически, то мы вынуждены создавать его многоступенчато. Сначала создаем массив указателей, потом каждый указатель инициализируем собственно массивом данных конкретного типа.

Если мы создадим динамический массив единым куском, то он не будет двухмерным с точки зрения языка Си++ - вы не сможете доступиться к его элементам стандартным оператором [][]. Так как в этом большом куске будут отсутствовать  указатели, которые будет искать данный оператор.

А когда этот оператор пытается найти искомые указатели в статическом массиве - то ему на вход передается уже другой тип данных, не int**, а int[3][4] - соответственно адрес конкретного элемента вычисляется по-другому.

Нельзя передать в функцию статический двухмерный массив как указатель именно из-за разного алгоритма вычисления смещения элемента. Функция, которая получит на вход двойной указатель будет вызывать оператор [][], относящияся именно к двойному указателю, а не к int[3][4].  

Именно поэтому, работать с именем массива как с двойным указателем возможно, но он не является двойным указателем  сам по себе и передавать его в функцию, преобразовав к двойному указателю будет ошибкой. Собственно также как и двойной указатель бессмыслено передавать в какую-либо функцию предварительно не проинициализировав его.
Например:




Нет и еще раз нет.
Если мы объявим 
char *s; - то это всегда указатель
char s[30]; - это совсем другой тип, это явно заданный массив и имеет тип char[30]

char *s = new char[100];
char *ss;
// Это уже динамический массив. Причем и s и ss имеют одинаковый тип.

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

Лично для меня массивом является то, с чем можно работать стандартными операторами массивов - это квадратные скобки. Поэтому варианты вычисления адреса в большом блоке я и не приемлю.

Добавлено @ 18:32


Естественно недопустимо. В языке не определены константы адреса. И только из-за этого. Инициализировать можно только вещами, которые понимает компилятор. А в языке определены числовые константы, логические, а адресные - нет. Он их просто не знает.




Это сообщение отредактировал(а) Anikmar - 27.4.2007, 18:34

а вчем различие?

Это я не задал адрес?