MyClass & myObj = otherObj;

потому, что ссылки ссылаются только на объекты на стеке?

И че, совсем никак низя взять референс на чтото в хипе?

Точка занимает один символ.

Ссылки можно использовать в шаблонных функциях с move semantics.

2.Когда функция сохраняет этот указатель куда-либо.

это, конечно, хороший финт, но он эквивалентен:

void func(const MyClass * obj)
{
}

MyClass * c = new MyClass;
func(&*c);

и смысла в таких преобразованиях нет.

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

Это совсем неправда.

и смысла в таких преобразованиях нет. очевидный минус - это отсутствие nullptr на ссылках.

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

к тому же передача объекта по ссылке в контейнер ведет к копированию объекта

И это правильно, ибо когда передают объект по ссылке, то предполагают что им попользуются и забудут про него (при этом совершенно не важно где он сам находится - в куче или ещё где-либо). Если уж захотелось его как-то запомнить, то нужно делать либо move, либо copy.

да, я наврал.

очевидный минус - это отсутствие nullptr на ссылках

Вообще-то это очевидный плюс

Но по факту это нигде не работает, потому в основном работает как элемент документации.

пример, пожалуйста. не пойму, о чем речь.

пример, пожалуйста. не пойму, о чем речь.

Можно сделать *ptr, гдe ptr по факту окажется равным nullptr, и узнать об этом только при обращении к ссылке. В каких-то простых случаях компилятор поймёт это на стадии компиляции, а в динамике никаких проверок нет.

Почему иногда поинтеры для передачи данных в функцию лучше?

Лучше они могут быть в двух экзотических случаях: 1) нужно показать, что ссылка не инициализирована (тогда передается nullptr) 2) алгоритм предполагает перезапись аргумента с указателем. Но чаще использование указателей (тем более голых) - признак Си головного мозга.

очевидный минус - это отсутствие nullptr на ссылках.

Это одновременно и очевидный плюс. То есть мы явно говорим, что валидное значение.

Почему иногда поинтеры для передачи данных в функцию лучше?

Потому что они никогда не лучше. Забудь про сырые указатели вообще.

Правило простое: Если не надо чего-то непременно требующего указатели, то используй ссылки.

потому, что ссылки ссылаются только на объекты на стеке?

4.2

Что за бред я только что прочитал в каментах? o_O Всем вон из профессии!!!1 А еще говорят мне что цпп не говно.

Главный зашквар ссылок — их нельзя переопределить, тоесть указывать они могут только на 1 объект. А указатели можно. Зачем использовать ссылки? Мозг обезьянок от цпп просто отказывается осиливать уберсложнейший синтаксис указателей, лол.

На чем основывается это простое правило?

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

int f(vector<int> *data) {
  return (*data)[0] + (*data)[1];
}

int f1(const vector<int> &data) {
  return data[0] + data[1];
}

А когда тебе понадобится указатель - ты поймешь (и да, в этом случае скорее всего надо будет передавать shared_ptr) :)

Зачем вводить людей в заблуждение? Не знаешь - пройди мимо. Или послушай тех, кто знает.

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

Нет, просто Страуструп не придумал лучше способа передачи объектов для перегрузки операторов.

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

и да, в этом случае скорее всего надо будет передавать shared_ptr

Ага, причём по ссылке :)

Нет, в этом случае копию надо, иначе смысла нету :)

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

Ссылки — это такой синтаксический сахар для указателей, находящийся в русле общего стремления C++ не давать программисту понять WTF is going on.

Единственный нормальный коммент на весь топик

Ссылки — это такой синтаксический сахар для указателей

Вранье. Указатели - всего лишь возможная реализация ссылок.

Вранье. Указатели - всего лишь возможная реализация ссылок.

Фигня. Указатели - это одна их низкоуровневых основ языка. Простой пример - для указателей доступны арфиметические операции, и они очевидно не доступны для ссылок.

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

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

ТС, читай: http://www.lib.ru/CPPHB/cpptut.txt#47

Главный зашквар ссылок — их нельзя переопределить, тоесть указывать они могут только на 1 объект.

Всем вон из профессии!!!

/0

uvv% cat test.cpp
#include <iostream>

int main(int argc, char** argv)
{
   int a = 1;
   int b = 2;
   int &r = a;
   std::cerr << "r = " << r << std::endl;
   r = b;
   std::cerr << "r = " << r << std::endl;
}
uvv% ./test
r = 1
r = 2

Now print values of a and b and r :)

Да, ступил. Оно ссылаемый объект и перезаписало.

ты же в а закинул b.

Да понял уже. Перепутал с указателем =)

Почему иногда поинтеры для передачи данных в функцию лучше?

а кто так говорит? в смысле откуда ты это взял? расшифруй, когда - иногда, почему лучше?

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

Бывает :)

Указатель - понятие низкого уровня, ссылка - высокого, нефиг их смешивать. У ссылок семантическая нагрузка выше.

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