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

Пример:

#include <iostream>

using namespace std;

int main()
{
  int i[] = { 1, 2, 3 };
  cout << i << endl; // Приведение имени массива к указателю на его первый элемент. Эквивалентно &i[0] или &(*i)                                                                                                                                                                                 
  cout << &i << endl; // <-- Адрес указателя на первый элемент

  cout << endl;
}

Запускаем:

[sergey@myhost cpp]$ g++ main.cpp && ./a.out
0xbfe11848
0xbfe11848

Как такое может быть? Ведь указатель на int и собственно int — разные обьекты и должны иметь разные адреса Вот так:

int i = 100;                                                                                                                                                                                                  
int* p = &i;                                                                                                                                                                                                    
cout << p << endl;                                                                                                                                                                                              
cout << &p << endl;

Спасибо.

Здравствуйте, Neavirc, Вы писали:

N>Скажите пожалуйста, почему адрес указателя на первый элемент массива точно такой же, как адрес самого первого элемента?
Это "фича" языка С(а вместе с ним и с++). Такое поведение указано в стандарте. так и задумано

N>Спасибо.

З_>Это "фича" языка С(а вместе с ним и с++). Такое поведение указано в стандарте. так и задумано

Спасибо, скачал стандарт, буду изучать

Я там опечатался немного, я ожидал такого поведения:

int i = 100;                                                                                                                                                                                                  
int* p = &i;                                                                                                                                                                                                    
cout << &i << endl;                                                                                                                                                                                              
cout << &p << endl;

Здравствуйте, dip_2000, Вы писали:

N>>Скажите пожалуйста, почему адрес указателя на первый элемент массива точно такой же, как адрес самого первого элемента?
_>Это "фича" языка С(а вместе с ним и с++). Такое поведение указано в стандарте. так и задумано

Искал в 8.3.4, 8.3.1 — не нашел. Где?

Здравствуйте, Neavirc, Вы писали:

N>Скажите пожалуйста, почему адрес указателя на первый элемент массива точно такой же, как адрес самого первого элемента?
N> int i[] = { 1, 2, 3 };
N>Как такое может быть? Ведь указатель на int и собственно int — разные обьекты и должны иметь разные адреса :wow: Вот так:

Ты хотел, чтобы выражение &i имело тип int**? А зачем? Всё равно его нельзя изменить.

Здравствуйте, AKh, Вы писали:

AKh>Здравствуйте, dip_2000, Вы писали:

N>>>Скажите пожалуйста, почему адрес указателя на первый элемент массива точно такой же, как адрес самого первого элемента?
_>>Это "фича" языка С(а вместе с ним и с++). Такое поведение указано в стандарте. так и задумано

AKh>Искал в 8.3.4, 8.3.1 — не нашел. Где?

4.2 Array-to-pointer conversion

Здравствуйте, Roman Odaisky, Вы писали:

RO>Ты хотел, чтобы выражение &i имело тип int**? А зачем? Всё равно его нельзя изменить.

Когда я прочитал у Страуструпа, что имя массива приводится к указателю на его элемент, я подумал, что на стеке действительно создается самый бычный указатель. Не обнаружив указателя, я удивился и пошел на РСДН искать правду

Использовать указатель я никак не собирался.

Здравствуйте, Neavirc, Вы писали:

N>Я там опечатался немного, я ожидал такого поведения:

N>int i = 100;
N>int* p = &i;
N>cout << &i << endl;
N>cout << &p << endl;

Так ведь неявное приведение массива к указателю — (int*)a (где int a[]={....}) является rvalue и не имеет адреса.
Ну а то, что массив целиком расположен в памяти там же, где расположены его элементы, — ничего удивительного
Ситуация чем-то похожа на

struct Foo
{
    int x;
    operator int*() { return &x; }
};

Foo foo;
cout << &foo << endl; // указатель на структуру
cout << foo << endl; // эквивалентно (int*)foo
cout << &foo[0] << endl; // эквивалентно &*((int*)foo+0), & и * сокращаем, +0 тоже сокращаем...
cout << (&foo == &foo.x) << endl; // true

Но как только ты заводишь ещё одну переменную для хранения указателя — то эта переменная обретает собственный адрес.
Заведёшь две переменные — будут два разных адреса...

Здравствуйте, Neavirc, Вы писали:

N>  int i[] = { 1, 2, 3 };
N>  cout << i << endl;

Здесь неявно выполняется стандартное преобразование array to pointer conversion, результатом которого является указатель на первый элемент массива.

N>  cout << &i << endl;

Здесь преобразование array to pointer conversion не выполняется, а берется адрес объекта "массив". Начало объекта "массив" совпадает с началом первого элемента массива, поэтому получаются одинаковые значения.

ЗЫ
Чтобы убедится, что ты работаешь с разными сущностями, попробуй такой пример:

int main()
{
  int i[] = { 1, 2, 3 };
  cout << i << '\t' << i+1 << endl;                               
  cout << &i << '\t' << &i+1 << endl;
  cout << endl;

  return 0;
}

Здравствуйте, Neavirc, Вы писали:

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

Так он и создается иногда. Хотя строго говоря не при приведении, а при последующем копировании приведенного указателя.

Кодт, Bell, большое спасибо за помощь