Привет всем!

Читаю "Программирование на языке Си" Афанасьева, появился вопрос... Автор пишет: "Следующие объявления переменных"

реализуют определенную схему размещения указателей на двумерный массив.
Согласно этой схеме доступ к элементу a[0][0] можно получить по указателям a, p, pa при помощи следующих ссылок: a[0][0], *a, **a[0], *p, **pa, *p[0].
Уже на этапе инициализации массива int *pa[3] = { a, a[1], a[2] }; компилятор генерит error: 'initializing' : cannot convert from 'int [3][3]' to 'int *'.

Помогите, пожалуйста, разобраться...

Вот на это ругается:


У вас pa имеет тип *[3], т.е. в каждом элементе указатель на int
А при инициализации вы первому элементу присваиваете a, который имеет тип [3][3];

Спасибо, но мне изначально было понятно, что в выражении int *pa[3] = { a, a[1], a[2] }; пытаются проинициализировать массив указателей целыми значениями.. Хорошо немного переформулирую вопрос.
Есть следующие объявления переменных:

В данном случае, инициализация массива p указателями на элементы ОДНОМЕРНОГО массива a представлена второй строчкой кода.
Теперь есть объявление МНОГОМЕРНОГО массива:

Как правильно проинициализировать массив указателей int *pa[3] элементами a[0][0],  a[1][0] и a[2][0] ?

Попробуйте так:


А инициализация {....} на сколько я помню допускается только константами (могу ошибаться - не помню, всегда инициализировал только константами, поэтому вопроса не возникало)

FiMa1, выбирай:

Ok, Dov, спасибо! До первого варианта уже сам додумался, а вот вариант int *pa[3] = { (int*)a, a[1], a[2] };  мне непонятен ... Здесь что указатель приводится к указателю на int? Не понимаю как это работает, поясните плз...



Anikmar, а что Вас смутило? Где используются НЕ константы?

Это сообщение отредактировал(а) FiMa1 - 21.4.2007, 13:23

Смутило, что a[...] может быть не константный. Но я не уверен - поэтому и написал, что точно не уверен.
Хотя если массив объявлен статическим - то наверное константы...
Просто ни разу так не делал - поэтому и засомневался.

Это ни кчемный вариант просто лажа какая-то
Вот самый правильный вариант

Насколько я знаю инициализатором переменной в си и си++ выступает любое выражение.
Т.е вы можете, например, использовать вызов функции.

Здесь указатель на указатель на int приводится к указателю на int. 
Имя массива а[][] имеет тип int**, т.е. указатель на указатель на int. Мы его приводим к типу int*, т.е. указатель на int. Почему? Потому, что каждый элемент массива pa[3] имеет тип int*, т.е. указатель на int.

apook, извини, но я не совсем согласен.... Этот вариант можно назвать самым правльным лишь только  с точки зрения читабельности кода. Здесь явно задано, что мы берем адрес элемента [ 0 ][ 0 ] массива а и присваиваем его первому элементу-указателю массива и т.д. для остальных элементов.
Тем не менее запись int *pa[3] = { a[0], a[1], a[2] }; это абсолютно тоже самое тому, что ты написал, т.к. символическое имя a массива - это уже по-сути "скрытый" указатель на первый элемент данного массива. Т.о. указание амперсанда & в начале каждого из элементов a не обязательно.

А вот по-поводу никчемности варианта int *pa[3] = { (int*)a, a[1], a[2] }; вопрос открытый.. Ведь это работает...

Dov однозначно рулит!!! Ему пасиб! Всем оставшимся не равнодушными тоже спасибо. Топик закрыт... 

Это сообщение отредактировал(а) FiMa1 - 21.4.2007, 13:59

 FiMa1  Да ты че не врубаешся в такую ерунду
int a[ 3 ] Dov привел к int *a это сущей воды пурга,

если знаешь че тогда спрашиваещ 

Ну, что же, apook, у тебя есть 3 варианта.
1. Обосновать своё утверждение и доказать свою правоту, тогда получишь +1 в репу.
2. Не обосновывать и ничего не доказывать, тогда получишь -1 в репу за необоснованый наезд.
3. Ивиниться за необоснованый наезд, тогда не получишь ничего. 

Желаю удачи.   

зачем вносить путанницу вот этим
 
вариантом.
он вообще тогда не доделан надо так

Не надо мугать меня минусами тебе во всякой ерунде наезды чудятся

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

Вынужден признать что моя решчь может показаться наездом
тада извиняй. Но не надо ни минусов не плюсов это не тот случай
Dov "Черт возьми" надеюсь ты не в обиде.....

Это сообщение отредактировал(а) apook - 21.4.2007, 14:29

Принято, проехали.   

dizzy1984, если сигнатура функции позволяет, то конечно. Но в данном случае

И в данном случае все верно. Дело в том, что необходимость указания приведения присуща только компиляторам cи++ в си void* приводится к любому другому указателю и без явной указки.
Пардон. Я писал и для того и для другого, тогда, конечно, мой пример работает только для си. Вы правы.

Это сообщение отредактировал(а) dizzy1984 - 21.4.2007, 14:50

кто тебе сказал? двумерный массив не тоже самое что указатель на указатель

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

Fazil6, в этой цитате написано, что Имя массива а[][] имеет тип int**, т.е. указатель на указатель на int. Если ты не понимаешь разницу между словами 'массив' и 'имя массива', то почитай какие-нить книжки по этой теме, а потом спрашивай кто мне что сказал.   

ну а вот это уже точно наезд... 
И какая же разница в данном случае? Я применил слово массив именно к его имени. И если тебе не нравится формулировка, то имя массива  не тоже самое что указатель на указатель.

это скомпилится?

как ты думаешь?

Вот видишь, разницу ты не понимаешь. И ещё хочешь о чём-то спорить. Поэтому я тебе и сказал, что бы ты сначала книжки почитал, а потом уже спорил. 

Осмелюсь вторгнуться в вашу дискуссию чтоб довести до вашего внимания тот факт что имя массива не является переменной.
тогда может ли оно иметь тип? Тип может иметь начальный элемент
массива синонимом расположения в памяти которого я вляется имя
массива, тогда имя массива int а[3][3] имеет тот тип который у а[0] его элемента, а у того тип int a[3], поскольку это не массив указателей, а
именно двумерный массив....или ( ) 

  Может запоздало комментирую, но вышеприведенная фраза непонятна...
И (int*)a[0]  и a[0] и *a и &(a[0][0]) это ОДНО И ТОЖЕ © Dov.
вообще можем написать:

все элементы массива pa - указатели на первый (нулевой) элемент массива a.

Это сообщение отредактировал(а) FiMa1 - 21.4.2007, 16:28

не цепляйся к словам. Я коментируя твою фразу и в ней указано имя массива и все сказанное мной относится именно к имени массива.
ок. Принимаем, что я ламер без доказательства. 
как насчет компиляции моего примера? 

в свете того что 

почему не приводится к int** ?

Ну просто нелепо показалось приведение к указателному характеру
одного единственного элемента массива

получилось
pa[0]--*a;
pa[1]--a[3];
pa[2]--a[3];
хитро как-то, хотя пускай так будет ладно...


Это почти одно и то-же, у указателя на массив и массива разный
принцип

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




Это сообщение отредактировал(а) apook - 21.4.2007, 17:12

Dov, ты не прав ,ты сам неверно выразился, а теперь еще и посылаешь книжки читать.

это два разных типа, а второй это как раз указатель на указатель, и это то к чему приципился Fazil6

Fazil6, если тебе так сильно хочется поспорить или, что было бы лучше, поучиться чему-нибудь хорошему, то открой соответсвующую тему, зачем же здесь оффтопить.   
По поводу этого.

попробуй так:

Ну, а по поводу передачи двумерного массива в ф-цию в качестве аргумента, и здесь на форуме и в инете полным полно разных примеров. Нужно только поиском пользоваться.    

так делать нельзя, они физически в памяти по разному расположены как ты себе представляешь обращение к элементам? вспоминаем арифметику указателей и понимаем почему написали ерунду.

тебе бы как раз не мешало бы их поочитать, прежде чем так яростно спорить

Блин, да что за день сегодня такой.   
vinter, ты вопрос читал? Изначально вопрос звучал так:

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

нет, я читал вашь спор, и исходил только из него.

Dov, вопросик в догонку - а как выполняется прведение указателя на указатель к у просто указателю.. я не нашел.. Ну в приведении double к int понятно дробная часть откидывается, а здесь не пойму как это срабатывает.. Подскажи плз.

ты без конца отправляешь меня учиться чему-то (правда ты не говоришь чему именно). Я по твоему, ничего не понимаю, но внятно свою позицию ты отстоять не можешь. По твоему если я не согласен с высказываемыми тобой суждениям , то это офтоп? Мне кажется, что я могу доказать, что ты не прав, а добиться каких-то внятных объяснений почему я не прав от тебя я не могу. Постоянно отсылаешь к книгам... Можешь привести пример книги хоть одной, которая по твоему откроет мне глаза на проблемы многомерных массивов и связанных с ними указателей?

Dov, 
Я привел конкретный пример и спрашиваю "почему он не компилится?" Я не спрашиваю "как его скомпилировать?" Чувствуешь разницу?
 
reinterpret_cast - это ложь компилятору и с его помощью можно заставить много чего скомпилироваться. 

 
если исправить, то скомпилится , но если 
, то мой пример должен компиллироваться без изменений. Я ведь пытаюсь использовать имя массива а[][] именно как  int**, но компилятор упорно отказывается. 

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

Эта фраза мне определенно нравится...

Имхо, правда больше на стороне Fazil6 здесь.

 +1.


Массив вообще не имеет законченного типа, а уж тем более int**. Этот факт тоже не один раз проскакивал и выяснялся в темах.
Dov, имхо, ты не прав.


Это сообщение отредактировал(а) JackYF - 22.4.2007, 00:27

JackYF, в чём я не прав? 
В этом?

Так я этого никогда не говорил. Я говорил только про имя массива, которое содержит адрес первого элемента массива, т.е. является указателем. 
Если массив состоит из элементов типа int, то имя массива имеет тип int*, т. е является указателем на 
тип int.

Отсюда следует, что и &ar[0] и ar имеют тип  int*, т.к. являются адресами. Абсолютно то же самое можно сказать и про двумерный массив, который, по сути, является одномерным массивом, каждый элемент которого так же является одномерным массивом, и про трёхмерный и т.д.

И в том, и в другом случае имя массива имеет тип  char**, так как содержит адрес первого элемента массива, который в свою очередь имеет тип char*.
Разыменуем и тот и другой и посмотрим:

Оба выдают одинаковый результат. Доступ к элементам абсолютно идентичен. Можно объявить этот массив и так, это ни на что не повлияет:


Показал на пальцах, но уж извиняйте, как смог. Добавлю только, что многие не понимают разницу между массивом и именем массива. 
Имя массива - это указатель, хотя и константный, но всё же указатель. Почему? Да хотя бы потому, что содержит адрес, а адреса могут хранить только указатели.
Массив - это последовательность элементов одного и того же типа, имеющих одно имя.
Отсюда следует, что имя массива это только часть массива, и что оно указывает на начало массива.

За сим откланиваюсь и иду спать, ибо лучше объяснить не смогу.   

Нет. Не имеет. Читаем Страуструпа и/или стандарт.




Нет, отсюда это не следует. Я тебе могу написать свой произвольный класс, который будет имитировать точно такое же поведение (возвращение элементов по индексу). Но у него явно не будет тип int*


Ха. Это ты к первому элементу матрицы так можешь обратиться через [0][0], так как смещений нет.

Постараюсь показать, что a[x][y] не имеет тип int**
Следующий код принципиально неверен:


Вторая часть этого кода работать принципиально не будет.


Это сообщение отредактировал(а) JackYF - 22.4.2007, 12:17

Следовательно утверждать, что имя массива имеет типа int* нельзя. К тому же похожий пример есть у Страуструпа - стр. 131

Добавлено @ 13:29
И вообще чего мы так спорим, если есть RTTI?

Выдаст int [2], но никак не int*.

Это сообщение отредактировал(а) Xenon - 22.4.2007, 13:31

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


вопервых не имеет тип  char** ,  а может использоваться в таком качестве, но опустим эти лингвистические нюансы - дело намного хуже.  ar1 ну никак не   char**. И все потому, что кое кто действительно не понимает разницу между массивом и именем массива.


вот именно, и что мы имеем? Имя ar1 это указатель на массив char[4]. Где здесь имя, которое можно представлять как указатель?
Запомни : имя двумерного массива интов - это указатель на массив интов, но не как не указатель на указатель на int именно по причине 

Опять же, RTTI :

Выдает char[3][4].  Нельзя приравнять два разных типа T[] и T* - это хоть и похожие вещи, но на самом деле разные.

Ух, скока накатали. Сразу говорю, что всё ни асилю.   

Оставлю без комментария, хотя этому перлу прямая дорога на башорг, имхо.


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


Каким образом ты это пытался показать, я так и не понял.   


То, что код не верен, это правда. Но я опять не понял, что именно не работает? Не компилится или не приводится или вывод не работает или выводит, но не правильно? Что не работает?   Если хочешь, что бы выводился массив можешь так сделать, например:

Или тебе надо, что бы в виде таблицы выводилось? Скажи "принципиально"   , что тебе нужно.

Fazil6, весь твой пост оставляю без комментариев, кроме двух фраз, а именно:


Эти, имхо, на башорг адназначна.  
 
Да, а по поводу этого:

Я уже говорил, но для тебя ещё раз повторю. ar1 это указатель на первый элемент массива, т.е. на строку(или массив, если хочешь) "qwe". А имя,  "которое можно представлять как указатель" звучит так(ты не поверишь) : ar1[0] или *ar1, как тебе больше нравится. 

Xenon, с тобой я соглашусь, конечно, но только  не сейчас. По той причине, что  ты не попадаешь в контекст текущей полемики. Здесь идёт разговор о типах данных в плане приведения типов...
 Что-то устал я уже, не могу правильно сформулировать, но это не важно. Ты в самом начале посмотри и всё поймёшь. 
Ну, типа того, что так сделать можно:

а так нельзя:

А может и можно, но я не знаю как. Тогда покажи.   

Камрады! Желаю всем удачи! 
А я из дискуссии выбываю. Притомился я тут с вами. Всем пока.   

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


не работает приведение типов в том виде, в котором ты утверждаешь.

не приведется это 

и не приведется именно потому, что твое утверждение по поводу многомерных массивов ошибочно.

повторяю, что имя многомерного массива можно использовать как указатель на его первый элемент, но 1-м элементом многомерного массива является массив, а не имя массива и рассматривать его в свою очередь указателем вкорне неправильно. Ты ведь сам просил не путать массив с его именем

кстати внизу есть ссылки. Вот например и там сразу рассматривается именно этот вопрос
http://forum.vingrad.ru/topic-98636.html




а как же  твои слова ???







Это сообщение отредактировал(а) Fazil6 - 22.4.2007, 22:14

Dov Повторяю :указатель это переменная, а имя массива переменной не является(Не по той причине что это константный указатель)
  Есть имя массива a и есть обьект массива с именем a[0], так вот они синонимы, в памяти 
не указывает, а есть начало массива. походу так и рассматривается компилятором.
  Есть указатель pa который являясь указателем выступает в роли имени массива, в памяти
он указывает на начальный элемент массива но сам им не является, он расположен в другом месте.

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

тогда уж имя массива это массив имен переменных 


Это сообщение отредактировал(а) apook - 23.4.2007, 04:58

Dov, зачем споришь, если сам давно понял, что неправ? Помог FiMa1 
разобраться - молодец. Но дальше:

это как раз ошибка, такое приведение, будь это так, недопустимо.
Fazil6 как раз и указал тебе на это. И привёл короткий и наглядный пример.
Допустим, элемент a[0][0] расположен по адресу 0x00123400. Получаем:
&a[0][0] = 0x00123400; &a[0][1] = 0x00123404; &a[1][0] = 0x0012340C;
a[0] = 0x00123400; a[1] = 0x0012340C;
a = 0x00123400;
*a = 11; (в исходном примере, или 0 в примере Fazil6). 
Именно это и означает, что a - указатель на int, а потому твоё первое 
приведение типа совсем не "пурга", а правильно работает.
Если бы a был указателем на указатель на int, это бы означало, что для 
доступа к этому int нужно брать *(*a), т.е. содержимое с адресом 11 (или 
0). 
Своим спором ты, с одной стороны, теряешь репутацию у тех, кому очевидна 
твоя неправота, с другой, что хуже, запутываешь начинающих. И зачем оно 
тебе надо?

Добавлено через 10 минут и 12 секунд
Для большей аккуратности вместо 
*a = 11;
Следовало бы написать 
*((int*)a) = 11;

Dov, ты в самом деле не прав [][] и ** это разные типы.
Будет правильно если ты разберешься в теме и тебе, похоже, стоит извениться перед 
Fazil6.

дабы прекратить спор раз и навсегд читаем: тут (А разве char a[] не эквивалентно char* a ?)

Это сообщение отредактировал(а) bel_nikita - 24.4.2007, 09:44

обоснования?


А ты запусти и узнаешь.



+1, поддерживаю.

bel_nikita имел ввиду это http://www.rsdn.ru/Forum/Message.aspx?mid=177690&only=1

Это сообщение отредактировал(а) Xenon - 23.4.2007, 18:32

Ничего не нужно выдавать. Нужно всего лишь написать одну строку:
и посмотреть, и убедиться, что выведется именно строка "qwe", так как она является первым элементом массива ar1.

Компилятор может и твердит, только я то здесь причём. Если я говорил, что int [][] это int**, то попрошу мою цитату в студию. Я говорил, и буду говорить, что имя массива(в данном случае двумерного массива целых чисел) имеет тип, который по русски называется указатель на указатель на инт, и обозначается так:  int**, подобно тому, как тип целых чисел имеет обозначение(в С/С++) int, а указатель на целое - int*. По этому я могу написать так:

 А если ты утверждаешь, что имя массива или же сам массив имеет тип int [][], то покажи мне, как нужно написать. Так, что ли, или как то иначе:
 

Это да, хотя никто не говорит в чём имеено. Вернее,  не соглашаются в том, чего  я  не говорил. 

А я откуда знаю, это ты должен знать. Мои примеры все компиллируются.

Где я давал этот код? Цитату в студию. Это твой код, а не мой. И я не обязан отвечать за то, что ты пишешь. 

Ну-у-уу, наконец-то дошло.  Я рад.      

Если рассматривать его, как одномерный массив массивов(например массив строк), то да. А если просто, как двумерный(например, двумерный массив одиночных символов), то нет. В этом случае 1-м элементом многомерного массива будет элемент с индексом[0][0], т.е. первый одиночный символ этого массива. 

Имя массива(например, целочисленного, в данном случае), не может быть не только первым, но и вообще никаким элементом массива, по одной простой причине. Имя массива это адрес певого элемена массива, т.е. указатель, а не целое число. Сколько раз я ещё должен это повторять, что бы до вас дошло?   

 Ур-ра, дошло.   Если кто не понял, эта фраза относится к слову 'массив', а не к слову 'имя массива'. 
Совершенно верно, массив это не указатель. Указателем является только адрес первого элемента массива, т.е. его(массива) имя.
Fazil6, как-то полосами до тебя доходит, имхо.   

   Вот видишь, я был прав, когда говорил тебе книжки почитать, а ты ещё обижался на меня за это. Ну, ладно, я не в обиде.    

Так это ж я не тебе говорил, а apook`у. Или ты хочешь, что бы я это к тебе применил?    
Кстати, прошу всех обратить внимание на то, что apook  после этого стал намного культурнее в общении, вот посмотрите на его посты до этого и после. Это две большие разницы. 
apook, ты молодец. Стало намного приятнее читать твои посты. Честно.   

А по поводу этого я скажу тебе так. Указатель, он указатель не потому, что он переменная или константа, или ещё что-то, а потому, что его значением является адрес, понимаешь? адрес той переменной или константы, или ещё чего-нибудь, на которую он указывает. Имя массива это, конечно, не полноценный указатель, у него есть некоторые ограничения, но он хранит адрес и поэтому можно считать его указателем, во всяком случае компилятор именно так и делает.  

Читай выше.   

Ну, что тут можно сказать? Читай книжки. Пока всё. 

Улыбнуло, даже слов нет.   



dizzy1984, читай выше или ткни меня носом, где я говорил, что это одно и то же. Про такой тип int[][], я только в этой теме узнал, что он вобще существует. И до сих пор не могу понять, как можно его, или к нему что-либо привести. 
 
Лады, постараюсь.   

Не вопрос, скажи только в чём я виноват.

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

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

Если кому-то не ответил, извините. Вас много, а я один тут за всех отбиваюсь.   
Всем удачи. 

  

Dov, Твое высокомерие переходит всякие границы...


возможно, ты сильно удивишься, но строка "qwe" имеет тип char[4] - и никакой другой (совсем не char*)



Бред... Ахинея... Приведи мне выдержку из стандарта или цитату из любой книги, где так будет написано (про двумерный массив и его имя и что его имя это указатель на указатель). Это указатель на первый элемент.  А  массив int a[3][3] является одномерным массивом массивов int[3], поэтому первым элементом будет массив и имя а является указателем на int[3] , а это не указатель и поэтому a не является указателем на указатель. 



вот это кто говорил? 

Именно с этим не соглашаются.



Ну ты же все знаешь.... Не можешь простейшие ошибки найти в пяти строках?
не компилится именно потому, что имя двумерного массива int не является указателем на указатель int (int**). Именно об этом говорит компилятор. Не надо только приводить доводы, что reinterpret_cast поможет. Если бы твои домыслы были верны, то пример обязан был компилироваться. 


Это мой код. Ты отвечай за себя. Скомпилится Это? a здесь имя массива. По твоему это int**, получается , что одному int** присваивается другой int**,что мешает здесь скомпилироваться? 





Вот только не надо строить из себя дядю наставляющего молодежь. После будешь выглядеть очень смешно...




Я хочу чтобы ты их к себе применил, раз уж берешь на себя ответственность делать замечания, то начни с себя.

вот еще примерчик


Добавлено @ 01:03

полный тест http://faqs.org.ru/progr/c_cpp/cfaqrus2.htm



Это сообщение отредактировал(а) Fazil6 - 24.4.2007, 01:04

  Fazil6, по моему это бесполезно, не трать ты нервы

Причём здесь высокомерие?
Fazil6, послушай меня. Вот ты не злись, когда читаешь, то, что я написал, а вдумывайся и старайся понять смысл написанного. Выкинь ты из головы эти стандарты, как будто нет их, ведь для того, что бы понять принцып работы они не нужны. Цитаты из книги я могу тебе дать, но книга написана на иврите. Если ты хочешь, я могу тебе дать цитаты с переводом на русский язык. Книгу написал Йоав Натив, израильский специалист.  Он автор многих книг по программированию, в частности по С/С++, системный аналитик, имеет научную степень. Кстати, это к твоему вопросу о том, кто мне сказал. И вобще, не важно, что кто где сказал. Важно понять, как это всё работает. 


Я понимаю, что компилятор тебе написал  char[4], но ты пойми, он это сделал для того, что бы ты увидел и понял к чему он придрался. Иначе, как он тебе это объяснит? Но сам он воспринимает эту строку именно, как  char*. 

Fazil6, говоришь ты всё правильно, но понимаешь не верно. Буду думать, как бы получше объяснить... Прийдётся чуть ли не каждом слове останавливаться, ну да ладно, попробую.
Вот этот int[3] тебя и путает, как видно. Давай пока я так скажу.  Массив int a[3][3] можно представить, как  одномерный массив, состоящий из 3 элементов(какого типа эти элементы поговорим ниже, но уж точно не  int[3]), каждый из которых является одномерным массивов, сосоящим из 3 элементов типа  int, т.е. из целых чисел. Стало быть, массив а имеет 3 подмассива(назовём их так, что бы не путаться в тетминах): a[0], a[1], a[2].
Рассмотрим подробнее подмассив а[0]. Это массив из 3 целых чисел типа int. Если а это имя для всего двумерного массива, то а[0] это имя только для этого подмассива. Ко всем трём элементам этого подмассива можно обращаться, указывая его имя а[0] и добавляя к нему индекс элемента. Что бы обратиться, например к последнему элементу, нужно написать a[0][2]. 
Поскольку этот подмассив, по-существу, является обычным  массивом, то его имя а[0] является указателем  на первый элемент а[0][0] и содержит его адрес. В этом легко убедиться. 

Выведется один и тот же адрес. Делаем вывод, что имя подмассива a[0] является указателем на первый элемент, так как хранит его адрес, поэтому имеет тип указатель на инт, т.е. int*. Это понятно?  
 Это правильно.
 Похоже это то место, где ты путаешься. Имя а является указателем не на int[3], а на первый элемент, т.е. на а[0] и содержит его адрес. Это тоже легко проверить. Это то же самое значение, что и в тех двух строчках, которые я привёл выше, т.е. адрес а[0][0], который хренится в указателе а[0].
 
Разыменуй его:
 И ты увидишь значение указателя а, т.е. адрес, который хранится в указателе а[0]. Это всё тот же адрес элемента с индексом а[0][0].
 Отсюда следует, что имя массива а, указывая на первый элемент т. е. на а[0], является указателем на указатель на инт, потому что, как мы выяснили выше, имя подмассива а[0] это указатель на инт. А поскольку имя массива а это указатель на указатель на инт, то он имеет тип int**. 

Все эти объяснения даны, как бы, с точки зрения компилятора, а не с точки зрения того, кто смотрит на экран монитора и видит там надпись int[][], а что это такое и как его применить он не знает.

Всё, на этом пока остановимся. Если кто не понимает моих объяснений, я не виноват. Я ни кому не навязываю своё мнение. Если кто-то считает, что int[3] или int[333] или int[3][3] это какой-то тип,  к которому можно хоть что-то привести, то ради бога, я не возражаю. Хотелось бы только взглянуть на это приведение.   

Ну, вот. Написал несколько строчек, а потратил на это несколько часов.   

Всем пока.


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

А почему, я уже устал объяснять. 
Удачи. 



Это сообщение отредактировал(а) Dov - 24.4.2007, 12:14

Dov, 
Чтобы понять разницу между int a[] и int *a  -  не нужно никаких книг, и уж тем более цитат. .
 Ну, давай посмотрим с точки зрения компилятора. Достачно простого примера и дизасма:
Смотрим через дизасм: 
Из этого всего видно, что a[3] и b[3] компилятор получает по-разному. 
Когда встречается а[3]: компилятор генерирует код, чтобы считать с позиции a[3]:
1) перемещается на три символа вперед
2) читает требуемый символ.

В случае b[3] компилятор генерирует код, чтобы начать с позиции b:
1) считывает значение указателя
2) прибавляет к указателю 3
3) читает символ, на который указывает указатель.

Т.е. int a[] != int *b.

очень смешно... Сам придумал? Когда-то строки определялись char*, но это было когда-то  и 


Страуструп. Язык программирования С++. Специальное издание.
стр. 84 

там же
стр.130



нифига подобного. Он воспринимает тип char[n]

вот довольно простой пример



ничего я не путаю. Это ты путаешь.

именно можно использовать, но не является. И по поводу первого элемента многомерного масива - это массив ибо Многомерный массив - это массив массивов.

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


ничего из этого не следует кроме того, что указатель и массив - это разные типы.

Хранятся ли в массиве char[10][10] указатели можно проверить с помощью окна Memory.