shared_ptr и ссылки в C++
Это не снисходительно относится к серверу сторона ..
Для стороны клиента, можно использовать ChannelFactory
4 ответа
Возьмите shared_ptr по значению, и счетчик ссылок увеличится. Это проще, если вы typedef it:
typedef boost:shared_ptr<object> object_ptr;
void foo(object_ptr obj)
{
obj->/* stuff*/;
obj.reset(); //only resets this local copy, that means:
// reduce reference count (back to 1), and
// set obj to point at null.
}
int main(void)
{
object_ptr obj(new object());
foo(obj);
}
Имейте в виду, что ссылки - это псевдонимы. Когда вы передаете ссылку, вы не передаете указатели, копии и т. Д., Вы создаете псевдоним другого объекта. (На самом деле они реализованы как указатели):
typedef boost:shared_ptr<object> object_ptr;
void foo(object_ptr& obj)
{
obj.reset(); // the references was never increased, since a copy has not
// been made, this *is* obj in main. so the reference
// goes to 0, and obj is deleted
}
int main(void)
{
object_ptr obj(new object);
foo(obj); // after this, obj has been reset!
}
Всегда помните о const правильном, чтобы предотвратить ошибки:
typedef boost:shared_ptr<object> object_ptr;
void foo(const object_ptr& obj)
{
obj.reset(); // cannot do!
}
int main(void)
{
object_ptr obj(new object);
foo(obj);
}
Я думаю, вы должны предпочесть передавать умные указатели в качестве ссылок, когда это возможно, чтобы избежать посторонних увеличивает и уменьшает (и копирует и еще много чего).
Будет ли увеличиваться общий указатель, когда его объект передается по ссылке в функцию?
Нет, поскольку вы обращаетесь к необработанному указателю, а затем передаете его. Вы хотите сделать что-то подобное:
f(shared_ptr<object> o){
//do something
}
int main(){
shared_ptr<object> p (new object());
f(p);
}
f (object & o) { //сделай что-нибудь } int main () { shared_ptr <объект> p (новый объект ()); f (* p); }Будет ли увеличиваться общий указатель? когда его объект передается по ссылке в функцию?
В приведенном выше коде - нет. p всегда будет иметь счетчик ссылок равный 1. Вы можете проверить это в отладчике. Счетчик ссылок shared_ptr подсчитывает количество экземпляров shared_ptr, указывающих на один и тот же объект, он не отслеживает ссылки, которые вы создаете, вызывая operator * (). И это не обязательно - поскольку p гарантированно живет до конца области видимости, а вызов функции находится в той же области (или глубже) p будет там во время весь вызов f (). Так что все ок.
... если только в f вы не возьмете адрес o и не сохраните где-нибудь, что будет длиться после возврата f . Этого следует избегать во что бы то ни стало - передайте shared_ptr, если вам нужно это сделать.
Перво-наперво, от функциональности С точки зрения C ++ ссылки точно такие же, как указатели. Они были добавлены в язык только для того, чтобы сделать синтаксис перегрузки операторов более естественным. (Например, чтобы можно было писать a + b вместо & a + & b)
Ваши образцы кода C и C ++ абсолютно не эквивалентны. Версия C вашего кода C ++ будет выглядеть так:
f(object *p){
//do something
}
int main(){
object o;
object_constructor(&o);
f(&o);
object_destructor(&o);
}
Фактически, это тот вид кода, который ваш компилятор C ++ будет концептуально генерировать.
Что касается вашего второго вопроса: Да, это правильный способ вызвать функция f. Счетчик общего указателя не увеличивается. Фактический указатель на объект будет передан, как если бы вы не использовали shared_ptr. Однако это безопасно, если f не делает ничего необычного. Просто помните, что происходит то же самое, как если бы параметр f принял указатель вместо ссылки. Единственное отличие состоит в том, что компилятор автоматически передает адрес переменной без необходимости явно использовать оператор &.
Я лично не люблю передавать переменные по ссылке (хотя передача по константной ссылке - это нормально).