En este artículo, analizaremos los punteros inteligentes en C++. ¿Qué son los punteros inteligentes, por qué y cómo usarlos correctamente?
Los punteros se utilizan para acceder a los recursos que son externos al programa, como la memoria del montón. Entonces, para acceder a la memoria del montón (si se crea algo dentro de la memoria del montón), se usan punteros. Al acceder a cualquier recurso externo, solo usamos una copia del recurso. Si le hacemos algún cambio, simplemente lo cambiamos en la versión copiada. Pero, si usamos un puntero al recurso, podremos cambiar el recurso original.
C++
#include <iostream> using namespace std; class Rectangle { private: int length; int breadth; }; void fun() { // By taking a pointer p and // dynamically creating object // of class rectangle Rectangle* p = new Rectangle(); } int main() { // Infinite Loop while (1) { fun(); } }
C++
#include <iostream> using namespace std; class SmartPtr { int* ptr; // Actual pointer public: // Constructor: Refer https:// www.geeksforgeeks.org/g-fact-93/ // for use of explicit keyword explicit SmartPtr(int* p = NULL) { ptr = p; } // Destructor ~SmartPtr() { delete (ptr); } // Overloading dereferencing operator int& operator*() { return *ptr; } }; int main() { SmartPtr ptr(new int()); *ptr = 20; cout << *ptr; // We don't need to call delete ptr: when the object // ptr goes out of scope, the destructor for it is automatically // called and destructor does delete ptr. return 0; }
C++
#include <iostream> using namespace std; // A generic smart pointer class template <class T> class SmartPtr { T* ptr; // Actual pointer public: // Constructor explicit SmartPtr(T* p = NULL) { ptr = p; } // Destructor ~SmartPtr() { delete (ptr); } // Overloading dereferencing operator T& operator*() { return *ptr; } // Overloading arrow operator so that // members of T can be accessed // like a pointer (useful if T represents // a class or struct or union type) T* operator->() { return ptr; } }; int main() { SmartPtr<int> ptr(new int()); *ptr = 20; cout << *ptr; return 0; }
C++14
#include <iostream> using namespace std; #include <memory> class Rectangle { int length; int breadth; public: Rectangle(int l, int b){ length = l; breadth = b; } int area(){ return length * breadth; } }; int main(){ unique_ptr<Rectangle> P1(new Rectangle(10, 5)); cout << P1->area() << endl; // This'll print 50 // unique_ptr<Rectangle> P2(P1); unique_ptr<Rectangle> P2; P2 = move(P1); // This'll print 50 cout << P2->area() << endl; // cout<<P1->area()<<endl; return 0; }
C++14
#include <iostream> using namespace std; #include <memory> class Rectangle { int length; int breadth; public: Rectangle(int l, int b) { length = l; breadth = b; } int area() { return length * breadth; } }; int main() { shared_ptr<Rectangle> P1(new Rectangle(10, 5)); // This'll print 50 cout << P1->area() << endl; shared_ptr<Rectangle> P2; P2 = P1; // This'll print 50 cout << P2->area() << endl; // This'll now not give an error, cout << P1->area() << endl; // This'll also print 50 now // This'll print 2 as Reference Counter is 2 cout << P1.use_count() << endl; return 0; }
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA