Как сделать ссылку на объект в c

Как передать объект класса по ссылке?

Если Вы «пытаетесь познать C++», то хотя бы книгу откройте по языку. Любую. Тогда таких вопросов появляться не будет.

21 июн 2016 в 18:02

Зря @ixSci читаете нравоучения. Q&A не для дискуссий и высоких материй. Вообще, сходу не нашел ответа на вопрос для Си++ в базе вопросов, так что сам по себе вопрос считаю адекватным, вот первый ответ, близкий по духу. Формулировка, вопроса конечно страдает, требуется правка. Лучше переформулируйте вопрос за автора, он просто не знает, что в нем написать. Думаю, против ни кто не будет.

21 июн 2016 в 18:41

Не понимаю, с чего вдруг Вы тут разводите цензуру. Не нравится вопрос — поднимайте тревогу, пусть модераторы решают. Совсем не обязательно дергать самолюбие авторов. Я вообще такие вопросы пропускаю мимо ушей. Этот привлек внимание как раз отрицательной оценкой.

22 июн 2016 в 8:04

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

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

Для начала рассмотрим принимающую сторону, т.е. функцию или метод класса, в который передается ссылка на объект. В простейшем случае это выглядит так:

void foo(ObjectType& object)

К типу передаваемого объекта добавляется символ & , причем его можно размещать как вплотную к типу, так и к имени объекта. Это зависит от стиля программирования.

При передачи объекта по ссылке не происходит копирования, т.е. мы по сути передаем адрес на объект, что быстрее и менее затратно по памяти. Плюс ко всему мы работаем непосредственно с объектом, переданным по ссылке. Если же объект исключительно входной и не должен быть изменен, то следует добавить модификатор const:

void foo(const ObjectType& object)

Теперь, изменить объект object в функции не получится. Чтобы было возможно вызывать методы класса object они должны быть объявлены как const . Следует отметить, что есть понятие «ссылки на константу» а есть «константная ссылка». В данном случае мы имеем дело с первым понятием.

Теперь перейдем непосредственно к передаче объекта. Тут есть три варианта:

ObjectType myObject; foo(myObject);

ObjectType* myObject = new ObjectType(. ); foo(*myObject);`

ObjectType& myObject = otherObject; foo(myObject);

Ссылки (references). Ссылки на переменные, структуры, объединения и объекты классов. Отличия между ссылками и указателями. Примеры

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

type & ref_var = var;

type – тип, на который объявляется ссылка;
ref_var – переменная типа «ссылка» на type ;
var – переменная типа type , на которую объявляется ссылка.

2. Примеры объявления и использования ссылки на переменную, структуру, объединение

Пример 1. Объявление ссылки с именем rd на переменную целого типа d .

int d; // переменная int & rd = d; // ссылка с именем rd на переменную d, инициализируется при объявлении d = 0; rd = 2; // d = 2 /* int & rd2; // ошибка (ссылка должна быть инициализирована при объявлении) */

Пример 2. Объявление ссылки на структурную переменную.

Пусть задан тип структуры, которая описывает дату:

struct Date < int day; int month; int year; >;

Тогда использование ссылки на структурную переменную типа Date может быть таким:

Date d; Date & rd = d; // ссылка на структуру Date // доступ к полям структуры по ссылке rd.day = 14; // d.day = 14 rd.month = 1; // d.month = 1 rd.year = 1972; // d.year = 1972

Пример 3. Объявление и использование ссылки на объединение

Пусть задано объединение TYPES :

union TYPES < int d[2]; char c[4]; float x; >;

Демонстрация использования ссылки на об¢единение TYPES :

TYPES t; // t - переменная типа "объединение" TYPES & rt = t; // ссылка на t char c; int d; rt.c[0] = 'A'; c = t.c[0]; rt.d[1] = 28; d = t.d[1];

3. Какое отличие между ссылкой и указателем?

Между ссылкой и указателем можно выделить следующие основные отличия:

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

4. Как объявить ссылку на объект некоторого класса? Пример объявления и использования

Пусть задан класс CFloat . В классе объявляется внутренняя переменная типа float , конструкторы и методы доступа Get() , Set() .

Пример демонстрирует использование ссылки на объект класса CFloat .

Программный код модуля, созданного по шаблону Win32 Console Application демонстрирующий использование ссылки на объект класса, имеет вид:

#include "stdafx.h" #include using namespace std; class CFloat < float x; public: // конструкторы класса CFloat() < x = 0; >CFloat(float nx) < x = nx; >// методы доступа float Get() < return x; > void Set(float nx) < x = nx; >>; int _tmain(int argc, _TCHAR* argv[]) < // ссылка на объект класса CFloat CFloat f; // f - объект класса CFloat CFloat & rf = f; // rf - ссылка на объект класса CFloat float x; rf.Set(5.5); // доступ к методам класса по ссылке x = f.Get(); // x = 5.5 f.Set(-8.2); x = rf.Get(); // x = -8.2 return 0; >

5. Можно ли объявить ссылку на тип void ? Существует ли тип void& ?

6. Можно ли изменить значение по ссылке, если оно объявлено с ключевым словом const (объявлено как константное)?

7. Как с помощью ссылки передать переменную или объект класса в функцию? Пример

С помощью ссылки можно передавать переменную или объект класса в функцию. Таким образом, в теле функции можно изменять значение переданной переменной.

Пример 1. Демонстрация передачи переменной типа int в функцию и изменения ее значения в теле функции. Приложение типа Win32 Console Application .

#include "stdafx.h" #include using namespace std; // функция Inc5() - увеличивает на 5 void Inc5(int & t) // передача t по ссылке < t += 5; >int _tmain(int argc, _TCHAR* argv[]) < int d; d = 5; Inc5(d); // d = 10 Inc5(d); // d = 15 return 0; >

Пример 2. В примере демонстрируется передача объекта класса по ссылке. Пусть задан класс CRadius и функция Volume() . В функцию Volume() передается объект класса CRadius по ссылке.

Передача объекта класса по ссылке есть более эффективной в сравнении с передачей по значению. Так как при передаче объекта по значению все данные объекта копируются в стек. Если в объекте есть много данных, то это сильно увеличивает время выполнения при вызове функции.

Текст программы, созданной по шаблону Win32 Console Application :

#include "stdafx.h" #include using namespace std; class CRadius < double radius; public: // конструкторы CRadius() < radius = 1; >CRadius(double nradius) < radius = nradius; >// методы доступа void Set(double nradius) < radius = nradius; >double Get() < return radius; > >; // вычисляет объем шара double Volume(CRadius & R) // передача по ссылке < double vol, radius; radius = R.Get(); vol = 4.0 / 3.0 * 3.1415 * radius * radius * radius; return vol; > int _tmain(int argc, _TCHAR* argv[]) < CRadius r(2.5); // экземпляр класса CRadius double vol; vol = Volume(r); // передача объекта класса по ссылке cout // vol = 65.4479 return 0; >

8. Каким образом возвратить ссылку из функции? Примеры

Функция может возвращать ссылку на объект. В этом случае, вызов функции может размещаться в левой части оператора присваивания (см. пример 2).

Пример 1. Демонстрируется возвращение из функции ссылки на тип int .

#include "stdafx.h" #include using namespace std; // возвращение ссылки из функции int & Inc5(int t) // функция увеличивает на 5 значение параметра t < t = t + 5; return t; > int _tmain(int argc, _TCHAR* argv[]) < int a, b; b = 7; a = Inc5(b); // a = 12 cout return 0; >

Пример 2. Демонстрируется изменение значения внешнего (глобального) массива A с помощью функции Change() , которая возвращает ссылку на элемент массива A с заданным индексом.

Текст демонстрационной программы, созданной по шаблону Win32 Console Application имеет следующий вид

#include "stdafx.h" #include using namespace std; #define MAX 20 double A[MAX]; // функция, которая возвращает ссылку на элемент массива A с индексом index double & Change(int index) < // возвратить значение элемента массива A return A[index]; > int _tmain(int argc, _TCHAR* argv[]) < int i; // заполнение массива for (i=0; i// A = // изменить значение элемента массива с индексом 5 с помощью функции ChangeA(5) = 3.25; // A[5] = 3.25; ChangeA(MAX-1) = -7.77; // A[19] = -7.77; return 0; >

9. Примеры инициализации структурной переменной с использованием ссылок

Показаны два способа инициализации структурной переменной.

Пример 1. Возврат ссылки на структурную переменную. Инициализация структурной переменной осуществляется в функции InitPixel() .

#include "stdafx.h" #include using namespace std; // структура пиксель struct Pixel < int x, y, color; >; // функция, которая возвращает ссылку на структуру Pixel & InitPixel(int value) < Pixel px; px.x = px.y = px.color = value; return px; > int _tmain(int argc, _TCHAR* argv[]) < Pixel px; Pixel px2 = InitPixel(5); // px2.x = 5; px2.y = 5; px2.color = 5; px = InitPixel(11); // px.x = 11; px.x = 11; px.x = 11; cout " - " " - " " - " " - " return 0; >

Пример 2. Инициализация структурной переменной типа Pixel . Функция InitPixel() получает ссылку на структурную переменную в качестве параметра.

#include "stdafx.h" #include using namespace std; // структура пиксель struct Pixel < int x, y, color; >; // функция, которая возвращает ссылку на структуру void InitPixel(Pixel & px, int x, int y, int color) < // изменение значения структурной переменной у функции px.x = x; px.y = y; px.color = color; return; > int _tmain(int argc, _TCHAR* argv[]) < Pixel px; Pixel px2; InitPixel(px, 3, 8, 10); // px.x = 3; px.y = 8; px.color = 11; InitPixel(px2, 5, 5, 8); // px2.x = 5; px2.y = 5; px2.color = 8; cout " - " " - " " - " " - " return 0; >

10. Какие существуют ограничения на работу со ссылками в C++?

В языке C++ работа с оссылками имеет свои ограничения:

ссылки не могут связываться с другими ссылками (только с переменными);
не существует нулевой ссылки;
ссылки должны быть инициализированы при их объявлении.

Связанные темы

C# Как сделать ссылку на объект [дубликат]

@aepot Там заголовок вопроса такой, сам ответ разжовывает разные мелочи по доступу к переменным, включая ту, что у автора в вопросе (цитата: Вопрос: А сможем ли мы получить доступ MyField из других классов, методов и др.? )

19 ноя 2020 в 12:22
Еще автору на заметку
19 ноя 2020 в 12:27

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Вам нужно объявить переменную SoC не в конструктора, а в классе, тогда она будет доступна:

namespace Killer < public partial class Form1 : Form < private Process[] SoC; public Form1() < InitializeComponent(); SoC = Process.GetProcessesByName("XR_3DA.exe"); >private void kill_Click(object sender, EventArgs e) < foreach (Process SoC1 in SoC) < SoC1.CloseMainWindow(); >> > >

Отслеживать
ответ дан 19 ноя 2020 в 12:12
Exploding Kitten Exploding Kitten
5,462 2 2 золотых знака 18 18 серебряных знаков 24 24 бронзовых знака

public partial class Form1 : Form < private Process[] SoC; public Form1() < InitializeComponent(); SoC = Process.GetProcessesByName("XR_3DA.exe"); >private void kill_Click(object sender, EventArgs e) < foreach (Process SoC1 in SoC) < SoC1.CloseMainWindow(); >> >

Дополнительно, крайне не рекомендуется вставлять свой код в конструктор формы. Рекомендую использовать обработчик события Form.Load для этого.

Исправленный код будет выглядеть так:

public partial class Form1 : Form < private Process[] SoC; public Form1() < InitializeComponent(); this.Load += Form1_Load; // вместо этой строчки можете назначить обработчик в дизайнере, а строчку убрать >private void Form1_Load(object sender, EventArgs e) < SoC = Process.GetProcessesByName("XR_3DA.exe"); >private void kill_Click(object sender, EventArgs e) < foreach (Process SoC1 in SoC) < SoC1.CloseMainWindow(); >> >

Указатели, ссылки и массивы в C и C++: точки над i

В этом посте я постараюсь окончательно разобрать такие тонкие понятия в C и C++, как указатели, ссылки и массивы. В частности, я отвечу на вопрос, так являются массивы C указателями или нет.

Обозначения и предположения

Я буду предполагать, что читатель понимает, что, например, в C++ есть ссылки, а в C — нет, поэтому я не буду постоянно напоминать, о каком именно языке (C/C++ или именно C++) я сейчас говорю, читатель поймёт это из контекста;
Также, я предполагаю, что читатель уже знает C и C++ на базовом уровне и знает, к примеру, синтаксис объявления ссылки. В этом посте я буду заниматься именно дотошным разбором мелочей;
Буду обозначать типы так, как выглядело бы объявление переменной TYPE соответствующего типа. Например, тип «массив длины 2 int’ов» я буду обозначать как int TYPE[2] ;
Я буду предполагать, что мы в основном имеем дело с обычными типами данных, такими как int TYPE , int *TYPE и т. д., для которых операции =, &, * и другие не переопределены и обозначают обычные вещи;
«Объект» всегда будет означать «всё, что не ссылка», а не «экземпляр класса»;
Везде, за исключением специально оговоренных случаев, подразумеваются C89 и C++98.

Указатели и ссылки

Указатели. Что такое указатели, я рассказывать не буду. 🙂 Будем считать, что вы это знаете. Напомню лишь следующие вещи (все примеры кода предполагаются находящимися внутри какой-нибудь функции, например, main):

int x; int *y = &x; // От любой переменной можно взять адрес при помощи операции взятия адреса "&". Эта операция возвращает указатель int z = *y; // Указатель можно разыменовать при помощи операции разыменовывания "*". Это операция возвращает тот объект, на который указывает указатель

Также напомню следующее: char — это всегда ровно один байт и во всех стандартах C и C++ sizeof (char) == 1 (но при этом стандарты не гарантируют, что в байте содержится именно 8 бит :)). Далее, если прибавить к указателю на какой-нибудь тип T число, то реальное численное значение этого указателя увеличится на это число, умноженное на sizeof (T) . Т. е. если p имеет тип T *TYPE , то p + 3 эквивалентно (T *)((char *)p + 3 * sizeof (T)) . Аналогичные соображения относятся и к вычитанию.

Ссылки. Теперь по поводу ссылок. Ссылки — это то же самое, что и указатели, но с другим синтаксисом и некоторыми другими важными отличиями, о которых речь пойдёт дальше. Следующий код ничем не отличается от предыдущего, за исключением того, что в нём фигурируют ссылки вместо указателей:

int x; int &y = x; int z = y;

Если слева от знака присваивания стоит ссылка, то нет никакого способа понять, хотим мы присвоить самой ссылке или объекту, на который она ссылается. Поэтому такое присваивание всегда присваивает объекту, а не ссылке. Но это не относится к инициализации ссылки: инициализируется, разумеется, сама ссылка. Поэтому после инициализации ссылки нет никакого способа изменить её саму, т. е. ссылка всегда постоянна (но не её объект).

Lvalue. Те выражения, которым можно присваивать, называются lvalue в C, C++ и многих других языках (это сокращение от «left value», т. е. слева от знака равенства). Остальные выражения называются rvalue. Имена переменных очевидным образом являются lvalue, но не только они. Выражения a[i + 2] , some_struct.some_field , *ptr , *(ptr + 3) — тоже lvalue.

Удивительный факт состоит в том, что ссылки и lvalue — это в каком-то смысле одно и то же. Давайте порассуждаем. Что такое lvalue? Это нечто, чему можно присвоить. Т. е. это некое фиксированное место в памяти, куда можно что-то положить. Т. е. адрес. Т. е. указатель или ссылка (как мы уже знаем, указатели и ссылки — это два синтаксически разных способа в C++ выразить понятие адреса). Причём скорее ссылка, чем указатель, т. к. ссылку можно поместить слева от знака равенства и это будет означать присваивание объекту, на который указывает ссылка. Значит, lvalue — это ссылка.

А что такое ссылка? Это один из синтаксисов для адреса, т. е., опять-таки, чего-то, куда можно класть. И ссылку можно ставить слева от знака равенства. Значит, ссылка — это lvalue.

Окей, но ведь (почти любая) переменная тоже может быть слева от знака равенства. Значит, (такая) переменная — ссылка? Почти. Выражение, представляющее собой переменную — ссылка.

Иными словами, допустим, мы объявили int x . Теперь x — это переменная типа int TYPE и никакого другого. Это int и всё тут. Но если я теперь пишу x + 2 или x = 3 , то в этих выражениях подвыражение x имеет тип int &TYPE . Потому что иначе этот x ничем не отличался бы от, скажем, 10, и ему (как и десятке) нельзя было бы ничего присвоить.

Этот принцип («выражение, являющееся переменной — ссылка») — моя выдумка. Т. е. ни в каком учебнике, стандарте и т. д. я этот принцип не видел. Тем не менее, он многое упрощает и его удобно считать верным. Если бы я реализовывал компилятор, я бы просто считал там переменные в выражениях ссылками, и, вполне возможно, именно так и предполагается в реальных компиляторах.

Более того, удобно считать, что особый тип данных для lvalue (т. е. ссылка) существует даже и в C. Именно так мы и будет дальше предполагать. Просто понятие ссылки нельзя выразить синтаксически в C, ссылку нельзя объявить.

Принцип «любое lvalue — ссылка» — тоже моя выдумка. А вот принцип «любая ссылка — lvalue» — вполне законный, общепризнанный принцип (разумеется, ссылка должна быть ссылкой на изменяемый объект, и этот объект должен допускать присваивание).

Теперь, с учётом наших соглашений, сформулируем строго правила работы со ссылками: если объявлено, скажем, int x , то теперь выражение x имеет тип int &TYPE . Если теперь это выражение (или любое другое выражение типа ссылка) стоит слева от знака равенства, то оно используется именно как ссылка, практически во всех остальных случаях (например, в ситуации x + 2 ) x автоматически конвертируется в тип int TYPE (ещё одной операцией, рядом с которой ссылка не конвертируется в свой объект, является &, как мы увидим далее). Слева от знака равенства может стоять только ссылка. Инициализировать (неконстантную) ссылку может только ссылка.

Операции * и &. Наши соглашения позволяют по-новому взглянуть на операции * и &. Теперь становится понятно следующее: операция * может применяться только к указателю (конкретно это было всегда известно) и она возвращает ссылку на тот же тип. & применяется всегда к ссылке и возвращает указатель того же типа. Таким образом, * и & превращают указатели и ссылки друг в друга. Т. е. по сути они вообще ничего не делают и лишь заменяют сущности одного синтаксиса на сущности другого! Таким образом, & вообще-то не совсем правильно называть операцией взятия адреса: она может быть применена лишь к уже существующему адресу, просто она меняет синтаксическое воплощение этого адреса.

Замечу, что указатели и ссылки объявляются как int *x и int &x . Таким образом, принцип «объявление подсказывает использование» лишний раз подтверждается: объявление указателя напоминает, как превратить его в ссылку, а объявление ссылки — наоборот.

Также замечу, что &*EXPR (здесь EXPR — это произвольное выражение, не обязательно один идентификатор) эквивалентно EXPR всегда, когда имеет смысл (т. е. всегда, когда EXPR — указатель), а *&EXPR тоже эквивалентно EXPR всегда, когда имеет смысл (т. е. когда EXPR — ссылка).

Массивы

Итак, есть такой тип данных — массив. Определяются массивы, например, так:

int x[5];

Выражение в квадратных скобках должно быть непременно константой времени компиляции в C89 и C++98. При этом в квадратных скобках должно стоять число, пустые квадратные скобки не допускаются.

Подобно тому, как все локальные переменные (напомню, мы предполагаем, что все примеры кода находятся внутри функций) находятся на стеке, массивы тоже находятся на стеке. Т. е. приведённый код привёл к выделению прямо на стеке огромного блока памяти размером 5 * sizeof (int) , в котором целиком размещается наш массив. Не нужно думать, что этот код объявил некий указатель, который указывает на память, размещённую где-то там далеко, в куче. Нет, мы объявили массив, самый настоящий. Здесь, на стеке.

Чему будет равно sizeof (x) ? Разумеется, оно будет равно размеру нашего массива, т. е. 5 * sizeof (int) . Если мы пишем

struct foo < int a[5]; int b; >;

то, опять-таки, место для массива будет целиком выделяться прямо внутри структуры, и sizeof от этой структуры будет это подтверждать.

От массива можно взять адрес ( &x ), и это будет самый настоящий указатель на то место, где этот массив расположен. Тип у выражения &x , как легко понять, будет int (*TYPE)[5] . В начале массива размещён его нулевой элемент, поэтому адрес самого массива и адрес его нулевого элемента численно совпадают. Т. е. &x и &(x[0]) численно равны (тут я лихо написал выражение &(x[0]) , на самом деле в нём не всё так просто, к этому мы ещё вернёмся). Но эти выражения имеют разный тип — int (*TYPE)[5] и int *TYPE , поэтому сравнить их при помощи == не получится. Но можно применить трюк с void * : следующее выражение будет истинным: (void *)&x == (void *)&(x[0]) .

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

Итак, мы объявили int x[5] . Если мы теперь пишем x + 0 , то это преобразует наш x (который имел тип int TYPE[5] , или, более точно, int (&TYPE)[5] ) в &(x[0]) , т. е. в указатель на нулевой элемент массива x. Теперь наш x имеет тип int *TYPE .

Конвертирование имени массива в void * или применение к нему == тоже приводит к предварительному преобразованию этого имени в указатель на первый элемент, поэтому:

&x == x // ошибка компиляции, разные типы: int (*TYPE)[5] и int *TYPE (void *)&x == (void *)x // истина x == x + 0 // истина x == &(x[0]) // истина

x[2] эквивалентно *(x + 2)
x + 2 относится к тем операциям, при которых имя массива преобразуется в указатель на его первый элемент, поэтому это происходит
Далее, в соответствии с моими объяснениями выше, x + 2 эквивалентно (int *)((char *)x + 2 * sizeof (int)) , т. е. x + 2 означает «сдвинуть указатель x на два int’а»
Наконец, от результата берётся операция разыменования и мы извлекаем тот объект, который размещён по этому сдвинутому указателю

Типы у участвовавших выражений следующие:

x // int (&TYPE)[5], после преобразования типа: int *TYPE x + 2 // int *TYPE *(x + 2) // int &TYPE x[2] // int &TYPE

Также замечу, что слева от квадратных скобок необязательно должен стоять именно массив, там может быть любой указатель. Например, можно написать (x + 2)[3] , и это будет эквивалентно x[5] . Ещё замечу, что *a и a[0] всегда эквивалентны, как в случае, когда a — массив, так и когда a — указатель.

Теперь, как я и обещал, я возвращаюсь к &(x[0]) . Теперь ясно, что в этом выражении сперва x преобразуется в указатель, затем к этому указателю в соответствии с вышеприведённым алгоритмом применяется [0] и в результате получается значение типа int &TYPE , и наконец, при помощи & оно преобразуется к типу int *TYPE . Поэтому, объяснять при помощи этого сложного выражения (внутри которого уже выполняется преобразование массива к указателю) немного более простое понятие преобразования массива к указателю — это был немного мухлёж.

А теперь вопрос на засыпку: что такое &x + 1 ? Что ж, &x — это указатель на весь массив целиком, + 1 приводит к шагу на весь этот массив. Т. е. &x + 1 — это (int (*)[5])((char *)&x + sizeof (int [5])) , т. е. (int (*)[5])((char *)&x + 5 * sizeof (int)) (здесь int (*)[5] — это int (*TYPE)[5] ). Итак, &x + 1 численно равно x + 5 , а не x + 1 , как можно было бы подумать. Да, в результате мы указываем на память, которая находится за пределами массива (сразу после последнего элемента), но кого это волнует? Ведь в C всё равно не проверяется выход за границы массива. Также, заметим, что выражение *(&x + 1) == x + 5 истинно. Ещё его можно записать вот так: (&x)[1] == x + 5 . Также будет истинным *((&x)[1]) == x[5] , или, что тоже самое, (&x)[1][0] == x[5] (если мы, конечно, не схватим segmentation fault за попытку обращения за пределы нашей памяти :)).

Массив нельзя передать как аргумент в функцию. Если вы напишите int x[2] или int x[] в заголовке функции, то это будет эквивалентно int *x и в функцию всегда будет передаваться указатель (sizeof от переданной переменной будет таким, как у указателя). При этом размер массива, указанный в заголовке будет игнорироваться. Вы запросто можете указать в заголовке int x[2] и передать туда массив длины 3.

Однако, в C++ существует способ передать в функцию ссылку на массив:

void f (int (&x)[5]) < // sizeof (x) здесь равен 5 * sizeof (int) >int main (void) < int x[5]; f (x); // OK f (x + 0); // Нельзя int y[7]; f (y); // Нельзя, не тот размер >

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

И что самое интересное, эту передачу можно использовать так:

// Вычисляет длину массива template size_t len (t (&a)[n])

Похожим образом реализована функция std::end в C++11 для массивов.

«Указатель на массив». Строго говоря, «указатель на массив» — это именно указатель на массив и ничто другое. Иными словами:

int (*a)[2]; // Это указатель на массив. Самый настоящий. Он имеет тип int (*TYPE)[2] int b[2]; int *c = b; // Это не указатель на массив. Это просто указатель. Указатель на первый элемент некоего массива int *d = new int[4]; // И это не указатель на массив. Это указатель

Однако, иногда под фразой «указатель на массив» неформально понимают указатель на область памяти, в которой размещён массив, даже если тип у этого указателя неподходящий. В соответствии с таким неформальным пониманием c и d (и b + 0 ) — это указатели на массивы.

Многомерные массивы. Если объявлено int x[5][7] , то x — это не массив длины 5 неких указателей, указывающих куда-то далеко. Нет, x теперь — это единый монолитный блок размером 5 x 7, размещённый на стеке. sizeof (x) равен 5 * 7 * sizeof (int) . Элементы располагаются в памяти так: x[0][0] , x[0][1] , x[0][2] , x[0][3] , x[0][4] , x[0][5] , x[0][6] , x[1][0] и так далее. Когда мы пишем x[0][0] , события развиваются так:

x // int (&TYPE)[5][7], после преобразования: int (*TYPE)[7] x[0] // int (&TYPE)[7], после преобразования: int *TYPE x[0][0] // int &TYPE

То же самое относится к **x . Замечу, что в выражениях, скажем, x[0][0] + 3 и **x + 3 в реальности извлечение из памяти происходит только один раз (несмотря на наличие двух звёздочек), в момент преобразования окончательной ссылки типа int &TYPE просто в int TYPE . Т. е. если бы мы взглянули на ассемблерный код, который генерируется из выражения **x + 3 , мы бы в нём увидели, что операция извлечения данных из памяти выполняется там только один раз. **x + 3 можно ещё по-другому записать как *(int *)x + 3 .

А теперь посмотрим на такую ситуацию:

int **y = new int *[5]; for (int i = 0; i != 5; ++i)

Что теперь есть y? y — это указатель на массив (в неформальном смысле!) указателей на массивы (опять-таки, в неформальном смысле). Нигде здесь не появляется единый блок размера 5 x 7, есть 5 блоков размера 7 * sizeof (int) , которые могут находиться далеко друг от друга. Что есть y[0][0] ?

y // int **&TYPE y[0] // int *&TYPE y[0][0] // int &TYPE

Теперь, когда мы пишем y[0][0] + 3 , извлечение из памяти происходит два раза: извлечение из массива y и последующее извлечение из массива y[0] , который может находиться далеко от массива y. Причина этого в том, что здесь не происходит преобразования имени массива в указатель на его первый элемент, в отличие от примера с многомерным массивом x. Поэтому **y + 3 здесь не эквивалентен *(int *)y + 3 .

Объясню ещё разок. x[2][3] эквивалентно *(*(x + 2) + 3) . И y[2][3] эквивалентно *(*(y + 2) + 3) . Но в первом случае наша задача найти «третий элемент во втором ряду» в едином блоке размера 5 x 7 (разумеется, элементы нумеруются с нуля, поэтому этот третий элемент будет в некотором смысле четвёртым :)). Компилятор вычисляет, что на самом деле нужный элемент находится на 2 * 7 + 3 -м месте в этом блоке и извлекает его. Т. е. x[2][3] здесь эквивалентно ((int *)x)[2 * 7 + 3] , или, что то же самое, *((int *)x + 2 * 7 + 3) . Во втором случае сперва извлекает 2-й элемент в массиве y, а затем 3-й элемент в полученном массиве.

В первом случае, когда мы делаем x + 2 , мы сдвигаемся сразу на 2 * sizeof (int [7]) , т. е. на 2 * 7 * sizeof (int) . Во втором случае, y + 2 — это сдвиг на 2 * sizeof (int *) .

В первом случае (void *)x и (void *)*x (и (void *)&x !) — это один и тот же указатель, во втором — это не так.