Указатель против ссылки

Что было бы лучше, если дать функции исходную переменную для работы:

unsigned long x = 4;

void func1(unsigned long& val) {
     val = 5;            
}
func1(x);

или:

void func2(unsigned long* val) {
     *val = 5;
}
func2(&x);

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

Мое правило:

Используйте указатели, если вы хотите выполнять с ними арифметику указателей (например, увеличивать адрес указателя для перехода по массиву) или если вам когда-либо придется передавать NULL-указатель.

Используйте ссылки в противном случае.

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

1. Как и во всех других местах, всегда будьте constверны.

   • Примечание. Это означает, среди прочего, что только выходные значения (см. Пункт 3) и значения, переданные по значению (см. Пункт 4), могут не иметь constспецификатора.

2. Передайте значение по указателю только в том случае, если значение 0 / NULL является допустимым вводом в текущем контексте.

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

   • Обоснование 2: Как называется , вы знаете, что все, что приходит, находится в пригодном для использования состоянии. Следовательно, для этого значения не требуется выполнять NULL-проверку или обработку ошибок.

   • Обоснование 3: Обоснования 1 и 2 будут выполняться компилятором . Всегда перехватывайте ошибки во время компиляции, если можете.

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

   • Обоснование: мы не хотим нарушать пункт 2 ...

4. Выберите «передать по значению» вместо «передать по константной ссылке», только если значение представляет собой POD ( простая старая структура данных ) или достаточно мало (по памяти) или другими способами достаточно дешево (по времени) для копирования.

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

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

Хотя есть несколько различных возможностей (независимо от того, может ли что-либо быть NULL) с указателем, наибольшее практическое различие для выходного параметра - это чисто синтаксис. Например, руководство по стилю Google C ++ ( https://google.github.io/styleguide/cppguide.html#Reference_Arguments ) обязывает только указатели для выходных параметров и разрешает только ссылки, которые являются константными. Аргументация заключается в удобочитаемости: что-то с синтаксисом значения не должно иметь смысловой смысл указателя. Я не предполагаю, что это обязательно правильно или неправильно, но я думаю, что дело здесь в том, что это вопрос стиля, а не правильности.

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

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

Лучшим решением в большинстве случаев (с точки зрения безопасности) является использование boost :: option . Это позволяет передавать необязательные значения по ссылке, а также в качестве возвращаемого значения.

// Sample method using optional as input parameter
void PrintOptional(const boost::optional<std::string>& optional_str)
{
    if (optional_str)
    {
       cout << *optional_str << std::endl;
    }
    else
    {
       cout << "(no string)" << std::endl;
    }
}

// Sample method using optional as return value
boost::optional<int> ReturnOptional(bool return_nothing)
{
    if (return_nothing)
    {
       return boost::optional<int>();
    }

    return boost::optional<int>(42);
}

Используйте ссылку, когда можете, используйте указатель, когда нужно. Из C ++ FAQ: «Когда я должен использовать ссылки, а когда я должен использовать указатели?»

указатели

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

• Указатель, который в данный момент не указывает на допустимое место в памяти, получает значение null (которое равно нулю)

  BaseType* ptrBaseType;
  BaseType objBaseType;
  ptrBaseType = &objBaseType;

• & Является унарным оператором, который возвращает адрес памяти своего операнда.

• Оператор разыменования (*) используется для доступа к значению, хранящемуся в переменной, на которую указывает указатель.

     int nVar = 7;
     int* ptrVar = &nVar;
     int nVar2 = *ptrVar;

Ссылка

• Ссылка (&) похожа на псевдоним существующей переменной.

• Ссылка (&) похожа на константный указатель, который автоматически разыменовывается.

• Обычно используется для списков аргументов функции и возвращаемых значений функции.

• Ссылка должна быть инициализирована при ее создании.

• Как только ссылка инициализируется на объект, она не может быть изменена для ссылки на другой объект.

• Вы не можете иметь пустые ссылки.

• Ссылка const может ссылаться на const int. Это делается с помощью временной переменной со значением const

  int i = 3;    //integer declaration
  int * pi = &i;    //pi points to the integer i
  int& ri = i;    //ri is refers to integer i – creation of reference and initialization

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

Рассмотрим ключевое слово C #. Компилятору требуется, чтобы вызывающий метод применял ключевое слово out к любым аргументам out, даже если он уже знает, есть ли они. Это предназначено для улучшения читабельности. Хотя с современными IDE я склонен думать, что это работа для подсветки синтаксиса (или семантики).

Передавайте по постоянной ссылке, если нет причин, по которым вы хотите изменить / сохранить содержимое, которое вы передаете.

Это будет самый эффективный метод в большинстве случаев.

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

указатели:

• Может быть назначен nullptr (или NULL).
• На сайте вызова вы должны использовать, &если ваш тип не является указателем, явно указав, что вы модифицируете свой объект.
• Указатели могут быть отскок.

Ссылки:

• Не может быть нулевым.
• После привязки не может измениться.
• Абоненты не должны явно использовать &. Это иногда считается плохим, потому что вы должны перейти к реализации функции, чтобы увидеть, изменился ли ваш параметр.

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

Ссылки особенно полезны для указания аргументов функции.

Для получения дополнительной информации см. «Путешествие по С ++» Бьярна Страуструпа (2014). Страницы 11-12.