суть ссылки, указателя и передачи по значению.

Главное: указатель может быть равен нулю, а ссылка всегда ссылается на объект. Тогда по значению передается адрес переменной

Ссылки придумали для неосиляторов указателей. Зачем? Потому что C++. Тебе еще многое предстоит узнать о C++. Именно узнать, не понять.

Имеем 2 вещи: указатель и копию. Дальше сам поймешь что где и зачем.

Ссылка -> ссылается на имя объекта

Что за бред. Пока учишься, считай ссылку указателем, к которому можно обращаться через ., а не через ->

В каких случаях применяется указатель, а в каких ссылки?

Когда не хочется или нет возможности ставить & при передаче параметра или когда значение указателя не может быть nullptr..

не на имя да, на сам объект.

Ссылка - это просто такой странный указатель.

Указатели - это низкоуровневая абстракция, семантика памяти. Ссылки - высокоуровневая, семантика объектов.

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

Но часто без указателей не обойтись: нулевой указатель, адресная арифметика, размещение объектов в куче.

В каких случаях применяется указатель, а в каких ссылки?

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

Передача значением в этом всём вообще имеет место?

Имеет.

Несколько случаев для использования указателей:

• хранение их в контейнерах
• если уже есть в тех же контейнерах, которые широко используются (иначе надоест разименовывать везде и будет смесь указателей/ссылок)
• в полях классов, так как использование ссылок там делает невозможным присваивания и компилятор больше не генерирует оператор присваивания и конструктор копирования автоматически

хранение их в контейнерах

можно, пожалуйста, «hello world» на c++ в качестве пояснения для контейнера std::vector<std::string>?

Имеет.

Кратко, но не понятно. :) Зачем вообще передавать значением если *var решение для всего. Ну например структура/класс огромная(ный), копию же её делать резона нет - много памяти.

контейнерах, которые широко используются

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

struct Node {
    Node *parent;
    std::vector<Node *> children;
    // etc.
};

а, понятно. Спасибо :)

Нет, «решений для всего» в IT не бывает. Прежде всего, есть семантика. Дать функции доступ к объекту на чтение (const T&), дать функции доступ к объекту на чтение/запись (T&) и дать функции копию объекта (T) - это всё разные и валидные кейсы. Да, есть случаи когда нужно именно передать копию. Далее, с точки зрения производительности передать небольшие объекты по значению быстрее чем по ссылке. Наконец, теперь есть move semantics, которая позволяет передавать по значению бесплатно.

Указатель, указывает на участок памяти где располагается переменная, сам является переменной.

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

Указатель указывает
Ссылка ссылается

А сепульки сепулируют?

Зачем вообще передавать значением если *var решение для всего.

Так себе решение. Лучше передавай параметры по ссылке. Если объект не подразумевает модификации - по константной.

Разбавлю мнение диванных программистов, мнением Bjarne Stroustrup и Herb Sutter

https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-ptr-ref

https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-in

https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-conventional

пример по второй ссылке:

void f1(const string& s);  // OK: pass by reference to const; always cheap
void f2(string s);         // bad: potentially expensive
void f3(int x);            // OK: Unbeatable
void f4(const int& x);     // bad: overhead on access in f4()

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

почему четвертое - bad? Всмысле откуда overhead - при передаче строки в первом пункте все нормально же.

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

Запилил мини бенч

#include <benchpress/benchpress.hpp>

 __attribute__((noinline)) int sum_ref(const int& a, const int& b)
{
    return a + b;
}


 __attribute__((noinline)) int sum_copy (const int a, const int b)
{
    return a + b;
}

BENCHMARK("sum_ref", [](benchpress::context* ctx) 
{
    int a = 5;
    int b = 9;
    ctx->reset_timer();
    for (size_t i = 0; i < ctx->num_iterations(); ++i) 
    {
        int res = sum_ref(a, b);
        benchpress::escape(&res);
    }
})

BENCHMARK("sum_copy", [](benchpress::context* ctx) 
{
    int a = 5;
    int b = 9;
    ctx->reset_timer();
    for (size_t i = 0; i < ctx->num_iterations(); ++i) 
    {
        int res = sum_copy(a, b);
        benchpress::escape(&res);
    }
})

sum_ref  2 ns/op
sum_copy 0 ns/op

__attribute__((noinline)) Использовался, что компилятор не заменил эту функцию, просто строчкой a + b.

Откуда оверхед? Вот можно посмотреть ассемблерный код: https://godbolt.org/g/DPggsU

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

0_0 спасибо.

Прикольный фреймворк бенчмарков :)

Ты не сказал еще про граблю с вызовом неконстантной функции из константной (error passing const as this).

Не за что. Вот ссылка:

https://github.com/cjgdev/benchpress

Может google benchmark или Nonius получше, но этот зато header only, и зависит только от stl, то есть легко переносить между системами и компиляторами, без заботы о линковке...

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

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

Это считается за UB, так что не может.

Указатель, указывает на участок памяти где располагается переменная

Если уж нужна точность, то располагается там объект а не переменная.

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

А исключения придумали для неосиляторов err != nil.

Решил сделать бенчмарк ещё и для относительно большой структуры.

#include <benchpress/benchpress.hpp>

struct big
{
double first;
double second;
double third;
double fourth;
double fifth;
};

 __attribute__((noinline)) double sum_ref(const big& a, const big& b)
{
    return a.first + b.second;
}


 __attribute__((noinline)) double sum_copy (const big a, const big b)
{
    return a.first + b.second;
}

BENCHMARK("sum_ref", [](benchpress::context* ctx) 
{
    big a;
    a.first = 9.0;
    big b;
    b.second = 5.0;
    ctx->reset_timer();
    for (size_t i = 0; i < ctx->num_iterations(); ++i) 
    {
        double res = sum_ref(a, b);
        benchpress::escape(&res);
    }
})

BENCHMARK("sum_copy", [](benchpress::context* ctx) 
{
    big a;
    a.first = 9.0;
    big b;
    b.second = 5.0;
    ctx->reset_timer();
    for (size_t i = 0; i < ctx->num_iterations(); ++i) 
    {
        double res = sum_copy(a, b);
        benchpress::escape(&res);
    }
})

sum_ref   2 ns/op
sum_copy  12 ns/op

sum_ref   2 ns/op
sum_copy  2 ns/op