Как я использую Параметры ссылки в C++?

Пара простых примеров, которые можно запустить в Интернете.

Первый использует обычную функцию, а второй использует ссылки:

• Пример 1 (без ссылки)
• Пример 2 (ссылка)

Изменить - вот исходный код на случай, если вам не нравятся ссылки:

Пример 1

using namespace std;

void foo(int y){
    y=2;
}

int main(){
    int x=1;
    foo(x);
    cout<<x;//outputs 1
}

Пример 2

using namespace std;

void foo(int & y){
    y=2;
}

int main(){
    int x=1;
    foo(x);
    cout<<x;//outputs 2
}

Не знаю, является ли это самым простым, но вот ...

typedef int Element;
typedef std::list<Element> ElementList;

// Defined elsewhere.
bool CanReadElement(void);
Element ReadSingleElement(void); 

int ReadElementsIntoList(int count, ElementList& elems)
{
    int elemsRead = 0;
    while(elemsRead < count && CanReadElement())
        elems.push_back(ReadSingleElement());
    return count;
}

Здесь мы используем ссылку для передачи нашего списка элементов в ReadElementsIntoList () . Таким образом, функция загружает элементы прямо в список. Если бы мы не использовали ссылку, то elems было бы копией переданного списка, в который были бы добавлены элементы, но тогда elems будет отброшен при возврате функции.

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

В ответе GMan дана информация о ссылках. Я просто хотел показать вам очень простую функцию, которая должна использовать ссылки: swap, которая меняет местами две переменные. Вот она для ints (как вы просили):

// changes to a & b hold when the function exits
void swap(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

// changes to a & b are local to swap_noref and will go away when the function exits
void swap_noref(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
}

// changes swap_ptr makes to the variables pointed to by pa & pb
// are visible outside swap_ptr, but changes to pa and pb won't be visible
void swap_ptr(int *pa, int *pb) {
    int tmp = *pa;
    *pa = *pb;
    *pb = tmp;
}

int main() {
    int x = 17;
    int y = 42;
    // next line will print "x: 17; y: 42"
    std::cout << "x: " << x << "; y: " << y << std::endl

    // swap can alter x & y
    swap(x,y);
    // next line will print "x: 42; y: 17"
    std::cout << "x: " << x << "; y: " << y << std::endl

    // swap_noref can't alter x or y
    swap_noref(x,y);
    // next line will print "x: 42; y: 17"
    std::cout << "x: " << x << "; y: " << y << std::endl

    // swap_ptr can alter x & y
    swap_ptr(&x,&y);
    // next line will print "x: 17; y: 42"
    std::cout << "x: " << x << "; y: " << y << std::endl
}

Существует более умная реализация swap для ints, которая не нуждается во временной. Однако, здесь я больше забочусь о ясности, чем об умности.

Без ссылок (или указателей) swap_noref не может изменять переданные ему переменные, а значит, просто не может работать. swap_ptr может изменять переменные, но он использует указатели, которые являются грязными (когда ссылки не подходят, указатели могут справиться с задачей). swap - самый простой.

Об указателях

Указатели позволяют делать то же самое, что и ссылки. Однако указатели накладывают на программиста большую ответственность за управление ими и памятью, на которую они указывают (тема называется "управление памятью", но пока не беспокойтесь об этом). Как следствие, ссылки должны быть вашим предпочтительным инструментом на данный момент.

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

Две основные операции над переменными - это получение текущего значения (делается просто с помощью имени переменной) и присвоение нового значения (оператор присваивания, '='). Значения хранятся в памяти (ячейка, в которой хранится значение, - это просто непрерывная область памяти). Например,

int a = 17;

получается что-то вроде (примечание: ниже "foo @ 0xDEADBEEF" означает переменную с именем "foo", хранящуюся по адресу "0xDEADBEEF". Адреса памяти были выдуманы):

             ____
a @ 0x1000: | 17 |
             ----

Все, что хранится в памяти, имеет начальный адрес, поэтому есть еще одна операция: получить адрес значения ("&" - оператор адреса). Указатель - это переменная, хранящая адрес.

int *pa = &a;

результаты:

              ______                     ____
pa @ 0x10A0: |0x1000| ------> @ 0x1000: | 17 |
              ------                     ----

Обратите внимание, что указатель просто хранит адрес памяти, поэтому у него нет доступа к имени того, на что он указывает. На самом деле, указатели могут указывать на вещи без имен, но это тема для другого дня.

Существует несколько операций над указателями. Вы можете разыменовать указатель (оператор "*"), что дает вам данные, на которые указывает указатель. Разыменование противоположно получению адреса: *&a - это тот же ящик, что и a, &*pa - это то же значение, что и pa, а *pa - это тот же ящик, что и a. В частности, pa в примере содержит 0x1000; * pa означает "int в памяти в месте pa", или "int в памяти в месте 0x1000". "a" также означает "int в месте памяти 0x1000". Другие операции над указателями - сложение и вычитание, но это тема для другого дня.

Давайте рассмотрим простой пример функции с именем increment , которая увеличивает свой аргумент. Рассмотрим:

void increment(int input) {
 input++;
}

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

int i = 1;
std::cout<<i<<" ";
increment(i);
std::cout<<i<<" ";

произведет 1 1 в качестве вывода.

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

void increment(int &input) { // note the & 
 input++;
}

изменение, внесенное во вход внутри функции, фактически вносится в фактический параметр. Это даст ожидаемый результат 1 2

// Passes in mutable references of a and b.
int doSomething(int& a, int& b) {
  a = 5;
  cout << "1: " << a << b;  // prints 1: 5,6
}

a = 0;
b = 6;
doSomething(a, b);
cout << "2: " << a << ", " << b;  // prints 2: 5,6

В качестве альтернативы,

// Passes in copied values of a and b.
int doSomething(int a, int b) {
  a = 5;
  cout << "1: " << a << b;  // prints 1: 5,6
}

a = 0;
b = 6;
doSomething(a, b);
cout << "2: " << a << ", " << b;  // prints 2: 0,6

Или версия const:

// Passes in const references a and b.
int doSomething(const int &a, const int &b) {
  a = 5;  // COMPILE ERROR, cannot assign to const reference.
  cout << "1: " << b;  // prints 1: 6
}

a = 0;
b = 6;
doSomething(a, b);

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