unique pointer c++11

std::unique_ptr is smart pointer, it is a part of C++11. It owns the object and in other word it implements the “exclusive ownership” (two pointer cannot point to same object). Technically std::unique_ptr is a class template and class template contains raw pointer and this raw pointer points to object.

Creation of an unique pointer:

{//type is int
std::unique_ptr<int>up{new int{5}};  
//type is std::string
std::unique_ptr<std::string>up1{new std::string{"digestcpp"}};
//type is int[] 
std::unique_ptr<int[]>up2{new int[3]{1,2,3}};
//type is user defined data type (class), A is class
std::unique_ptr<A> up3{new A};
}//destructor will be called and heap memory will be released

Restriction inside unique pointer (below operations are not permitted):

• copy operation is prohibited (copy constructor is declared as “deleted function”)
• Assignment operator is prohibited (copy constructor is declared as “deleted function”)

std::unique_ptr<int> up{new int{5}};
std::unique_ptr<int> up4{up};//if we try copy operation then compiler will give below error
std::unique_ptr<int> up5{};
up5=up;                      //if we Assignment operator then compiler will give below error
error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&)
error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>& std::unique_ptr<_Tp, _Dp>::operator=(const std::unique_ptr<_Tp, _Dp>&)

Access the object in unique pointer:

• deference by operator* (if unique pointer manages single object then we can access the object using operator*)
• deference by operator-> (if unique pointer manages single object then we can access the object’s member function using operator->)
• deference by get() member function (if unique pointer manages single object then we can access the object’s pointer using get())
• deference by operator[] (if unique pointer manages array of objects then we can access individual object using operator[])

std::unique_ptr<int> up{new int{5}};
std::cout<<"Int Value:"<<*up<<std::endl;

std::unique_ptr<std::string> up1{new std::string{"digestcpp"}};
std::cout<<"Unique pointer has -> operation:"<<up1->append(".com")<<std::endl;

std::unique_ptr<int[]> up2{new int[3]{1,2,3}};
std::cout<<"Int[0] Value:"<<up2[0]<<std::endl;

int* pIptr= up.get();//return pointer pointing to actual object
std::cout<<"Int value using get():"<<*pIptr<<std::endl;

Header file:
#include<memory> under namespace std as std::unique_ptr
Source code with example:

/*
Program:Unique Pointer 
Author: Alpha Master
Date: 21 Feb 2021
*/

//Header File
#include<iostream>
#include<memory>

class A
{
};

int main()
{
    std::cout<<"Unique Pointer"<<std::endl;

    //Unique pointer has int
    std::unique_ptr<int> up{new int{5}};
    std::cout<<"Int Value:"<<*up<<std::endl;

    //Unique pointer has string
    std::unique_ptr<std::string> up1{new std::string{"digestcpp"}};
    std::cout<<"String Value:"<<*up1<<std::endl;
    std::cout<<"Unique pointer has -> operation:"<<up1->append(".com")<<std::endl;

    //Unique pointer has int[]
    std::unique_ptr<int[]> up2{new int[3]{1,2,3}};
    std::cout<<"Int[0] Value:"<<up2[0]<<std::endl;

    //Unique pointer has user defined data type
    std::unique_ptr<A> up3{new A};
    //std::cout<<"Int Value:"<<*up<<std::endl;

    //Using get() member function
    int* pIptr= up.get();
    std::cout<<"Int value using get():"<<*pIptr<<std::endl;


    return 0;
}

Output:

Unique Pointer
Int Value:5
String Value:digestcpp
Unique pointer has -> operation:digestcpp.com
Int[0] Value:1
Int value using get():5

unique pointer with function: 
We want to pass the unique pointer to function that we have 2 option:

• Pass by reference (actual object will be accessible in function)
• Pass by actual object (Need to do std::move() while calling)

If we want to return the unique pointer from function then just return it (internally it will use move operation so no need to worry)

/*
Program:Unique Pointer with function
Author: Alpha Master
Date: 4 April 2021
*/

//Header File
#include<iostream>
#include<memory>



std::unique_ptr<int> fun1(int tmp)
{
    std::unique_ptr<int>up{new int(tmp)};
    std::cout<<"Value in fun1:"<<*up<<std::endl;
    return up;
}

void fun2(std::unique_ptr<int>& tmp)
{
   std::cout<<"Value in fun2:"<<*tmp<<std::endl;
   return;
}


std::unique_ptr<int> fun3(std::unique_ptr<int> tmp)
{
    std::cout<<"Value in fun3:"<<*tmp<<std::endl;
    return tmp;
}


int main()
{
    std::cout<<"Unique Pointer with function"<<std::endl;
    std::unique_ptr<int>A = fun1(5);
    std::cout<<"Value first time:"<<*A<<std::endl;
    fun2(A);
    std::cout<<"Value second time:"<<*A<<std::endl;
    std::unique_ptr<int>B = fun3(std::move(A));
    std::cout<<"Value third time:"<<*B<<std::endl;

    
    return 0;
}

Output:

Unique Pointer with function
Value in fun1:5
Value first time:5
Value in fun2:5
Value second time:5
Value in fun3:5
Value third time:5

unique pointer with class:

/*
Program:Unique Pointer with external class
Author: Alpha Master
Date: 4 April 2021
*/

//Header File
#include<iostream>
#include<memory>



class A
{
    std::unique_ptr<int>m_upI;
    std::unique_ptr<std::string>m_upS;
    public:
    A(int i, std::string s)
    {
        std::cout<<"In A Constructor"<<std::endl;
        m_upI.reset(new int(i));
        m_upS.reset(new std::string(s));
    }
    ~A()
     { 
         std::cout<<"In B Destructor"<<std::endl;
         m_upI.reset(nullptr);
         m_upS.reset(nullptr);
     }
     int getInt()
     {
         return (*m_upI);
     }
     std::string getString()
     {    return (*m_upS);}
};

int main()
{
    std::cout<<"Unique Pointer with Class"<<std::endl;
    {
        A obj(5, "digestcpp.com");
        std::cout<<"Int:"<<obj.getInt()<<std::endl;
        std::cout<<"String:"<<obj.getString()<<std::endl;
    }
    std::cout<<"Outside Block"<<std::endl;
    return 0;
}