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

компилятор должен был бы быть уверен, что структура, которая передается (как названо в коде вызова) в, не изменяется

double x; // using non structs, oh-well

void Foo(double d)
{
      x += d; // ok
      x += d; // Oops
}

void main()
{
     x = 1;
     Foo(x);
}

Передача ссылкой является просто синтаксическим сахаром для pass-by-address/pointer. Таким образом, функция должна неявно разыменовать указатель для чтения значения параметра. Разыменование указателя могло бы быть более дорогим (если в цикле) затем копия структуры для копии значением.

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

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

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

Ваш компилятор должен был бы обнаружить a) то нечто, не изменяет структуру; b) то нечто, не делает никакого вычисления на физическом местоположении элементов структуры; И c) это вызывающая сторона, или другой поток, порожденный вызывающей стороной, не изменяет структуру, прежде чем нечто будет закончено, работая.

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

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

Вы можете быть удивлены, что обратная оптимизация, продвижение аргумента , на самом деле реализована в LLVM. Это преобразовывает ссылочный аргумент в аргумент значения (или агрегат в скаляры) для внутренних функций с небольшими числами полей, которые только читаются из. Это особенно полезно для языков, которые передают почти все ссылкой. Если Вы следуете за этим с мертвое устранение аргумента , Вы также не должны передавать поля, которые не затронуты.

Это переносит упоминание, что оптимизацию, которая изменяет путь функция, называют, может только работать, когда оптимизируемая функция является внутренней к скомпилированному модулю (Вы получаете это путем объявления функции static в C и с шаблонами в C++). Оптимизатор должен зафиксировать не только функцию, но также и все извещатели. Это делает такую оптимизацию справедливо ограниченной в объеме, если Вы не делаете их во время ссылки. Кроме того, оптимизацию никогда не называли бы, когда конструктор копии вовлечен (как другие плакаты упомянули), потому что она могла потенциально изменить семантику программы, которую никогда не должен делать хороший оптимизатор.

Это верно, что компиляторы на некоторых языках могли сделать это, если у них есть доступ к вызванной функции и если они могут предположить, что вызванная функция не будет изменяться. Это иногда упоминается как глобальная оптимизация, и кажется вероятным, что некоторый C или компиляторы C++ на самом деле оптимизировали бы случаи, такие как это - более вероятно путем встраивания кода для такой тривиальной функции.

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

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

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

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

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

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

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