как всетаки сильно желание выдать желаемое за действительное.... Я и код привел тебе, на который компиллятор упорно твердит, что 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.