Семантика передачи по ссылке по умолчанию в C++

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

1. Где вы передаете локальную копию переменной

   void myFunct(int cantChangeMyValue)
   

2. Где вы передаете локальную копию указателя на переменную

   void myFunct(int* cantChangeMyAddress) {
       *cantChangeMyAddress = 10;
   }
   

3. Если вы передаете «ссылку», но с помощью магии компилятора это так же, как если бы вы передавали указатель и просто разыменовывали его каждый раз.

   void myFunct(int & hereBeMagic) {
       hereBeMagic = 10; // same as 2, without the dereference
   }
   

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

То, что вы предлагаете, не позволит программисту сделать номер 1. Я лично считаю, что было бы плохой идеей отказаться от этой возможности. Один из основных плюсов C / C++ - мелкозернистое управление памятью. Передача всего по ссылке - это просто попытка сделать C++ более похожим на Java.

Да, я считаю, что это довольно сбивающая с толку перегрузка.

Вот что Microsoft говорит о ситуации:

Do not confuse reference declarations with use of the address-of operator. When & identifier is preceded by a type, such as int or char, then identifier is declared as a reference to the type. When & identifier is not preceded by a type, the usage is that of the address-of operator.

Я не очень хорошо разбираюсь в C или C++, но у меня возникают большие головные боли, разбирая различные варианты использования * и & на обоих языках, чем я кодирую на ассемблере.

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

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

Каждая перестановка (по значению / по ссылке и константная / неконстантная) имеет важные различия, которые определенно не эквивалентны.

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

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

Кодовая база, полностью верная по константам, идет еще дальше, добавляя константу в конец прототипов. Рассматривать:

void Foo::PrintStats( void ) const {
   /* Cannot modify Foo member variables */
}

void Foo::ChangeStats( void ) {
   /* Can modify foo member variables */
}

Если вам нужно передать объект Foo в функцию с префиксом const, вы можете вызвать PrintStats (). Компилятор выдает ошибку при вызове ChangeStats ().

void ManipulateFoo( const Foo &foo )
{
    foo.PrintStats();  // Works
    foo.ChangeStats(); // Oops; compile error
}

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

Основная причина, по которой ссылки были добавлены в C++, - это для поддержки перегрузки оператора; если вам нужна семантика «передачи по ссылке», у C был вполне разумный способ сделать это: указатели.

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

Также см

I do want to change the argument, should I use a pointer or should I use a reference? I don't know a strong logical reason. If passing ``not an object'' (e.g. a null pointer) is acceptable, using a pointer makes sense. My personal style is to use a pointer when I want to modify an object because in some contexts that makes it easier to spot that a modification is possible.

из того же FAQ.

есть что-то непонятное. когда ты сказал:

int b(b &param);

что ты задумал для второй «б»? ты забыл ввести тип? ты забыл написать иначе по отношению к первой «б»? Вам не кажется, что можно написать что-то вроде:

class B{/*something...*/};
int b(B& param);

С этого момента, я полагаю, вы имеете в виду то, что я пишу.

Теперь ваш вопрос: «Не думаете ли вы, что будет лучше, если компилятор будет рассматривать каждую передачу по значению не-POD как передачу по ссылке?». Первая проблема в том, что это нарушит ваш контракт. Я полагаю, вы имеете в виду передачу по CONST-ссылке, а не только по ссылке.

Теперь ваш вопрос сводится к следующему: «знаете ли вы, есть ли какая-нибудь директива компилятора, которая может оптимизировать вызов функции по значению?»

Теперь ответ - «не знаю».

Я думаю, что C++ станет очень запутанным, если вы начнете смешивать все виды доступных параметров с их константными вариациями.

Отслеживание всех вызовов конструкторов копирования, всех перегруженных разыменований и т. д. Быстро выходит из-под контроля.