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

Но адресных констант в языке нет, в ранних версиях я еще встречал описание причины - дескать язык высокого уровня не должен быть зависим от архитектуры машины, в современном стандарте даже упоминаний нет. В разделе константы - там есть целые числа, числа с плавающей точкой, строковые и символьные константы и служебные константы true и false. Больше нет. 

Да и посудите сами: допустим процессор motorola для видеоприставок. Был еще в конце 80-х годов. На тот момент intel был еще 16 разрядным, а motorola уже имела прямую 32-битную адресацию.
Ка должна выглядеть адресная константа? При всем при том, что на Си можно было писать и обработчики прерываний и драйверы. Тогда для семейства x86 она должна выглядеть как-то так: 000CC:000dd - т.е. сегмент + смещение, а для мотороловского процессора уже как 32 битное единое число без сегментации: как-то так. сссааа00 Причем int был все равно 16-разрядным.

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

И с появлением 64-разрядных систем в 32 разрядный int указатель уже не запихаешь. А не за горами 128 разрядные.

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

FiMa1, хорошо, что тебе понравилось, наверное в воскресенье-понедельник попробую дописать вторую часть. 
К продолжающим споритьЧестно говоря, я уже перестал понимать предмет спора. Может и 
остальные тоже спорят просто по инерции? Зайди сюда ортодоксальный астматик, он бы долго 
смеялся: "Я полагал, что между плюсанутыми и аштеэмельщиками разницы особой нет, но не 
настолько же? Придумали какое-то мифическое чудище, и сами же его и испугались". Вот, 
допустим, есть у нас структуры, описывающие разные физические сущности: корабль, 
автомобиль, кухонный стол, кролик, десяток кроликов. И есть ещё один тип: union, элементы 
которого - объекты перечисленных выше структур. Структуры содержат различные элементы, 
занимают разный объём памяти. Определена одна переменная, тип её - как раз тот самый
union. Я заполняю эту переменную данными, которые описывают автомобиль. Конечно, можно
считать фокусом: объявляю указатель на переменную как на автомобиль, потом чудом (просто 
указанием компилятору понимать его по-другому) рассматриваю это как кухонный стол, потом как кролика, а потом опять как автомобиль, и использую в последнем значении именно как автомобиль. И выдаю это за свои сверхспособности: смотрите какой фокусник. Да нет здесь никаких фокусов, и ловкости рук никакой нет, одно примитивное мошенничество. Что я могу, чтобы находящийся в здравом уме и трезвой памяти использовал в качестве кухонного стола автомобильное колесо с фарой и не заметил разницы? Или считается, что для int* и int** это чем-то принципиально отличается (подумаешь, втихаря нарисую/сотру звёздочку, никто и не заметит)?

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


На большее стандартный компилятор не способен.   


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

Две страницы я благополучно успел пропустить...
И все же спор у нас был о двух вещах:

1. тип "Массив" != тип "Указатель". Это так, теоретические изыскания.

2. Неправильная работа конкретного примера. То есть, что


Пример выведет два разных числа в лучшем случае. В худшем и AV/SegFault может схлопотать.


Ln78, а вообще во многом ты прав.
По данным двум пунктам мы спорили, спорили... А теперь о чем спорим?

Было  пожелание:



Я набросал пару примеров.

И началось...   

А ничего толком не началось. Корректного примера я так и не увидел. Или я что-то пропустил? Если да, то ткните в цитату или ссылку на этот корректный рабочий пример.

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

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

А то получается какое-то барство. Сначала:


А потом извольтес-с-с..:


У вас в роду дворян не былос-с-с?

  

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

показано использование a как int**, если он таковым не является? 

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



Ох... Я просил пример, который доказывает, что массив или имя его можно использовать как int** ,  а не пример в котором показаны действия с неким массивом и "если бы переменная была int**, то выглядело бы все именно так". 



что нет?

Я именно так и говорил всегда. 


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



ну принято считать что вот здесь пример демонстрирует
http://forum.vingrad.ru/index.php?showtopi...t&p=1114611
и вот тут
http://forum.vingrad.ru/index.php?showtopi...t&p=1114678

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

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

Встречный вопрос. А как я с ним работаю с точки зрения конструкций языка? Привожу к другому типу? Я работаю с ним как с двойным указателем. Почему не так? С какими стандартными типами данных языка Си++ допустимы такие операции?


Обсуждения до этого хоть я и читал, к теме моего ответа никак не относятся. Я ни скем не спорил. Было предложение привести пример кода, в котром имя двухмерного массива использовылось бы как двойной указатель, причем правильно.
Я привел пример доступа к элементу массива, используя его имя в качестве двойного указателя. В чем я спорю, кого я оспорил и что я сделал неправильно? Имя массива использовалось как двойной указатель? ДА. Без каких либо ухищрений! Без приведений типа и т.п.
Доступ к элементу массива получили? ДА. 
Код рабочий? ДА!

А потом мне объяснют, что это частный случай, что int и указатель размером одинаковы и т.п. 

Я всего лишь ответил на пост. Дайте мне рабочий пример. - Дал. Работает - ДА. В чем я не прав, объясните?

Теперь получается, нет, он не подходит. Так как нельзя передать в функцию. Не вопрос. Передайте в функцию двойной массив не указывая его размерности? Используя только имя массива. Нельзя. Потому, что статический массив намертво привязан к своим измерениям. Таким образом, предложите мне пример функции, которая в качестве параметра получает статический двухмерный массив любой размерности. Давайте вместе разберем получившийся код.

Добавлено через 2 минуты и 24 секунды
P.S.

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

Какие операции? Весь смысл примера сводится к тому, что **a даст в итоге значение типа int (если a это двумерный массив int). Я согласен с этим, но я говорю, что этот пример не доказвыает, что a это int**. Я просил пример, который это доказал бы. Поэтому я и говорю, что этот пример меня не устраивает. Поэтому я и вспоминаю передачу в функцию массива.


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

??? действия его будут однозначны - получить значение <type>  - если a это int **a, то значение будет int. Какие зависимости?
Пример:

Будет выведен результат 100 и это однозначно. имя массива использовано как двойной указатель? ДА
Ваше требование:

Выполнено? ДА!

Не понимаю... Какие примеры еще  надо привести?

 
зависимости от типа a. Компиллятор использует информацию о типе а для получения результата **а


Нет. Имя массива использовано как указатель на массив, а не как двойной указатель и компиллятор действует в этом случае не так как если бы это был двойной указатель.  Я же писал, что **(a +1) в случае если a типа int** компиллятор выполнит смещение на sizeof(int*)*1, а если int a[2][2], то выполнит sizeof(int[2])*1 

sizeof в этих случаях выдает разные результаты и поэтому компилятор никогда не рассматривает двумерный массив как двойной указатель и **a выглядит как работа с двойным указателем , но на самом деле является работой с указателем на массив в твоем примере. Поэтому я и сказал, что меня этот пример не устраивает


 Это не мое требование. Это смысл твоего примера.
мое требование 

читай внимательнее, что я пишу

Что вы имели в виду?

смещение. Значение выражения a+1 при 

получим адрес на 4 больше, а при

на 8 потому что sizeof(int[2]) == 8