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

Небольшое вступление доступно на странице Умные указатели - что, почему, что?.

Один из простых типов умных указателей -std::auto_ptr (глава 20.4.5 стандарта C ++), которая позволяет автоматически освобождать память, когда она выходит из области видимости, и является более надежной, чем простое использование указателя при возникновении исключений, хотя и менее гибкая.

Еще один удобный типboost::shared_ptr, который реализует подсчет ссылок и автоматически освобождает память, когда не осталось ссылок на объект. Это помогает избежать утечек памяти и прост в использовании для реализации RAII.

Тема подробно рассматривается в книге «Шаблоны C ++: Полное руководство» Дэвида Вандевурда, Николая М. Хосуттиса, глава Глава 20. Умные указатели. Некоторые темы:

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

Среди других вещей (хорошо объясненных в других ответах) использование умного указателя является возможным решением Как мы используем абстрактный класс в качестве возвращаемого типа функции? который был отмечен как дубликат этого вопроса. Тем не менее, первый вопрос, который нужно задать, если возникает желание указать абстрактный (или фактически любой) базовый класс в качестве возвращаемого типа в C ++, это «что вы на самом деле имеете в виду?». Существует хорошее обсуждение (с дальнейшими ссылками) идиоматического объектно-ориентированного программирования на C ++ (и как это отличается от других языков) в документации библиотека контейнеров указателей. Таким образом, в C ++ вы должны думать о владении. Какие умные указатели помогают вам, но не являются единственным решением или всегда полным решением (они не дают вам полиморфную копию) и не всегда являются решением, которое вы хотите показать в своем интерфейсе (а возвращаемая функция звучит ужасно очень похоже на интерфейс). Например, может быть достаточно вернуть ссылку. Но во всех этих случаях (умный указатель, контейнер указателя или просто возвращение ссылки) вы изменили возврат сценност в какой-то формессылк. Если вам действительно нужна копия, вам может потребоваться добавить больше шаблонной «идиомы» или перейти от идиоматического (или иного) ООП в C ++ к более общему полиморфизму с использованием таких библиотек, как Adobe Poly или Boost.TypeErasure.

http: //sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.htm

Умный указатель - это объект, который действует, выглядит и ощущается как обычный указатель, но предлагает больше функциональности. В C ++ интеллектуальные указатели реализованы в виде шаблонных классов, которые инкапсулируют указатель и переопределяют стандартные операторы указателя. У них есть ряд преимуществ перед обычными указателями. Они гарантированно инициализируются как нулевые указатели или указатели на объект кучи. Направление через нулевой указатель проверяется. Удаление никогда не требуется. Объекты автоматически освобождаются, когда последний указатель на них исчезает. Одна значительная проблема с этими умными указателями состоит в том, что в отличие от обычных указателей, они не уважают наследование. Умные указатели непривлекательны для полиморфного кода. Ниже приведен пример реализации умных указателей.

Пример

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

Этот класс реализует умный указатель на объект типа X. Сам объект находится в куче. Вот как это можно использовать:

smart_pointer <employee> p= employee("Harris",1333);

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

cout<<*p;
p->raise_salary(0.5);

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

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

Например,Увеличени предоставляет следующие реализации интеллектуальных указателей:

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

Кроме того, стандартная библиотека C ++ предоставляет три умных указателя;std::unique_ptr для уникального владельца,std::shared_ptr для совместного владения иstd::weak_ptr. std::auto_ptr существовал в C ++ 03, но теперь устарел.

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

Вы можете очень хорошо использовать эти указатели аналогично тому, как любое распределение работает в Java. В java сборщик мусора делает то же самое, в то время как в Smart Pointers это делается деструкторами.

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

Автоматический указатель, хотя и выглядит похожим, полностью отличается от интеллектуального указателя. Это удобный класс, который освобождает ресурс всякий раз, когда объект автоматического указателя выходит из области видимости переменной. В некоторой степени это делает указатель (на динамически выделяемую память) похожим на переменную стека (статически выделяется во время компиляции).

предоставленные Крисом, Сергдевом и Ллёдом, верны. Я предпочитаю более простое определение, просто чтобы сохранить мою жизнь простой: умный указатель - это просто класс, который перегружает-> а также* операторы. Это означает, что ваш объект семантически выглядит как указатель, но вы можете сделать так, чтобы он делал более крутые вещи, включая подсчет ссылок, автоматическое уничтожение и т. Д.shared_ptr а такжеauto_ptr в большинстве случаев достаточно, но они сопровождаются собственным набором небольших идиосинкразий.

на 3 типа:

1)Raw указатели :

T a;  
T * _ptr = &a; 

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

Указатели с постоянными данными или адресом {Читать в обратном направлении}

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

Указатель на тип данных T, который является константой. Это означает, что вы не можете изменить тип данных с помощью указателя. то есть*ptr1 = 19; не будет работать. Но вы можете перемещать указатель. то естьptr1++ , ptr1--; и т. д. будет работать. Читать в обратном направлении: указатель на тип T, который является константой

  T * const ptr2 ;

Постоянный указатель на тип данных T. Это означает, что вы не можете перемещать указатель, но вы можете изменить значение, на которое указывает указатель. то есть*ptr2 = 19 будет работать ноptr2++ ; ptr2-- и т. д. не будет работать. Читайте задом наперед: постоянный указатель на тип T

const T * const ptr3 ; 

Постоянный указатель на постоянный тип данных T. Это означает, что вы не можете ни переместить указатель, ни изменить указатель типа данных на указатель. то естьptr3-- ; ptr3++ ; *ptr3 = 19; не будет работат

3) Умные Указатели: #include <memory> }

Shared Pointer:

  T a ; 
     //shared_ptr<T> shptr(new T) ; not recommended but works 
     shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe

     std::cout << shptr.use_count() ; // 1 //  gives the number of " 
things " pointing to it. 
     T * temp = shptr.get(); // gives a pointer to object

     // shared_pointer used like a regular pointer to call member functions
      shptr->memFn();
     (*shptr).memFn(); 

    //
     shptr.reset() ; // frees the object pointed to be the ptr 
     shptr = nullptr ; // frees the object 
     shptr = make_shared<T>() ; // frees the original object and points to new object

Реализовано использование подсчета ссылок для отслеживания количества «вещей», указывающих на объект, на который указывает указатель. Когда этот счетчик становится равным 0, объект автоматически удаляется, то есть объект, на который возражают, удаляется, когда все share_ptr, указывающие на объект, выходят из области видимости. Это избавляет от головной боли, связанной с необходимостью удалять объекты, выделенные вами с помощью new.

Слабый указатель: Помогает справиться с циклической ссылкой, которая возникает при использовании общего указателя. Если у вас есть два объекта, на которые указывают два общих указателя, и есть внутренний общий указатель, указывающий на общий указатель каждого другого, тогда будет циклическая ссылка, и объект не будет удален когда общие указатели выходят из области видимости. Чтобы решить эту проблему, измените внутренний член с shared_ptr на weak_ptr. Примечание. Чтобы получить доступ к элементу, на который указывает слабый указатель, используйте lock (), это возвращает слабый_прит.

T a ; 
shared_ptr<T> shr = make_shared<T>() ; 
weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr 
wk.lock()->memFn() ; // use lock to get a shared_ptr 
//   ^^^ Can lead to exception if the shared ptr has gone out of scope
if(!wk.expired()) wk.lock()->memFn() ;
// Check if shared ptr has gone out of scope before access

Видеть : Когда полезен std :: weak_ptr?

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

unique_ptr<T> uptr(new T);
uptr->memFn(); 

//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr
uptr.reset() ; // deletes the object pointed to by uptr 

Чтобы изменить объект, на который указывает уникальный ptr, используйте семантику перемещения

unique_ptr<T> uptr1(new T);
unique_ptr<T> uptr2(new T);
uptr2 = std::move(uptr1); 
// object pointed by uptr2 is deleted and 
// object pointed by uptr1 is pointed to by uptr2
// uptr1 becomes null 

Ссылки: по сути, они могут быть как константные указатели, то есть указатели, которые являются константными и не могут быть перемещены с лучшим синтаксисом.

Видеть : Каковы различия между переменной-указателем и ссылочной переменной в C ++?

r-value reference : reference to a temporary object   
l-value reference : reference to an object whose address can be obtained
const reference : reference to a data type which is const and cannot be modified 

Ссылка :https: //www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_n Спасибо Андре за указание на этот вопрос.

например «char *», за исключением того, что когда указатель выходит из области видимости, то то, на что он указывает, также удаляется. Вы можете использовать его, как обычный указатель, используя «->», но не тогда, когда вам нужен фактический указатель на данные. Для этого вы можете использовать "& * ptr".

Это полезно для:

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

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

Вы можетен хотите использовать умный указатель, когда:

Смотрите также

Это очень удобно, потому что вам больше не нужно думать об утилизации предметов вручную.

Самыми распространенными умными указателями являютсяstd::tr1::shared_ptr (илиboost::shared_ptr) и режеstd::auto_ptr. Я рекомендую регулярное использованиеshared_ptr.

shared_ptr очень разносторонний и имеет дело с большим разнообразием сценариев удаления, включая случаи, когда объекты должны быть «переданы через границы DLL» (обычный кошмарный случай, если разныеlibcs используются между вашим кодом и DLL).

http: //en.wikipedia.org/wiki/Smart_pointe

В компьютерных науках интеллектуальный указатель - это абстрактный тип данных, который имитирует указатель, предоставляя при этом дополнительные функции, такие как автоматический сбор мусора или проверка границ. Эти дополнительные функции предназначены для уменьшения ошибок, вызванных неправильным использованием указателей при сохранении эффективности. Умные указатели обычно отслеживают объекты, которые на них указывают, с целью управления памятью. Неправильное использование указателей является основным источником ошибок: постоянное распределение, освобождение и ссылки, которые должны выполняться программой, написанной с использованием указателей, очень вероятно, что произойдут некоторые утечки памяти. Умные указатели пытаются предотвратить утечки памяти, делая автоматическое освобождение ресурсов: когда указатель на объект (или последний в ряду указателей) уничтожается, например, из-за того, что он выходит из области видимости, указанный объект также уничтожается.

умный указатель std :: shared_ptr не имеет оператора подписки и не поддерживает арифметику понтеров, мы можем использовать get () для получения встроенного указателя.