В чем разница между указателем и ссылкой в C++? Объясните на примерах

Основные различия между указателем и ссылкой в C++

Вы правильно заметили, что и указатели, и ссылки позволяют работать с данными через адрес в памяти. Однако между ними есть фундаментальные различия, которые важно понимать.

1. Инициализация и переназначение

Ссылка должна быть инициализирована при объявлении и никогда не может быть переназначена на другой объект:

int a = 5;
int b = 10;
int& ref = a;  // OK: ref ссылается на a
ref = b;       // НЕ переназначает ref на b! Это присваивает значение b в a (a = 10)
// ref все еще ссылается на a

Указатель может быть объявлен без инициализации и переназначен в любое время:

int a = 5;
int b = 10;
int* ptr = &a;  // OK: ptr указывает на a
ptr = &b;       // OK: теперь ptr указывает на b
*ptr = 20;      // b = 20

2. Null и неопределенные значения

Указатель может быть nullptr (или NULL), что означает "не указывает ни на что":

int* ptr = nullptr;
if (ptr) { // проверка на null
    *ptr = 5; // безопасно только если ptr не null
}

Ссылка не может быть null. Она всегда должна ссылаться на существующий объект. Это делает ссылки более безопасными — вам не нужно проверять их на null перед использованием.

3. Арифметика и доступ к памяти

Указатели поддерживают арифметические операции (+, -, ++, --) для перемещения по массивам:

int arr[] = {1, 2, 3, 4, 5};
int* ptr = arr;      // указывает на arr[0]
ptr++;               // теперь указывает на arr[1]
int val = *(ptr + 2); // получает arr[3]

Ссылки не поддерживают арифметику. Они просто псевдоним для объекта.

4. Синтаксис использования

При работе через указатель нужно использовать оператор разыменования *:

void increment(int* p) {
    (*p)++; // нужно разыменовать
}

int x = 5;
increment(&x); // передаем адрес

Ссылка используется как обычная переменная:

void increment(int& r) {
    r++; // не нужно разыменовывать
}

int x = 5;
increment(x); // передаем как есть

Когда что использовать?

• Используйте ссылки для передачи параметров в функции, когда объект гарантированно существует и не нужно его переназначать. Это безопаснее и чище синтаксически.
• Используйте указатели когда:
  • Нужна возможность указывать на nullptr (опциональные параметры)
  • Нужно переназначить на другой объект
  • Работаете с динамической памятью (new/delete)
  • Нужна арифметика указателей (например, для работы с массивами)
  • Реализуете полиморфизм через базовые классы

Пример: функция swap

Функция обмена значений через указатели:

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int x = 1, y = 2;
swap(&x, &y); // явно передаем адреса

Та же функция через ссылки:

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int x = 1, y = 2;
swap(x, y); // чище синтаксис

Таким образом, ссылки — это "безопасные указатели" для большинства задач, а указатели дают больше гибкости и контроля, но требуют осторожности.

std::string getString() { return "hello"; }

const std::string& ref = getString(); // время жизни временного объекта продлено
std::cout << ref; // OK

void process(std::string&& str) { // rvalue-ссылка
    // str можно переместить, а не копировать
}

process(std::string("temp")); // OK