std::experimental::propagate_const<T>:: propagate_const
      From cppreference.com
     
     
     
     
      
       <
       
        cpp
       
        |
       
        experimental
       
        |
       
        propagate const
       
      
     
     
     
     | 
           
            
             constexpr
            
            propagate_const
            
             (
            
            
             )
            
            
             =
            
            
             default
            
            
             ;
            
           
           | (1) | (library fundamentals TS v2) | 
| 
           
            
             constexpr
            
            propagate_const
            
             (
            
            propagate_const
            
             &&
            
            p
            
             )
            
            
             =
            
            
             default
            
            
             ;
            
           
           | (2) | (library fundamentals TS v2) | 
| 
           
            
             template
            
            
             <
            
            
             class
            
            U
            
             >
            
             /* see below */ constexpr propagate_const ( propagate_const < U > && pu ) ; | (3) | (library fundamentals TS v2) | 
| 
           
            
             template
            
            
             <
            
            
             class
            
            U
            
             >
            
             /* see below */ constexpr propagate_const ( U && u ) ; | (4) | (library fundamentals TS v2) | 
| 
           
            propagate_const
            
             (
            
            
             const
            
            propagate_const
            
             &
            
            
             )
            
            
             =
            
            delete
            
             ;
            
           
           | (5) | (library fundamentals TS v2) | 
       Let
       
        t_
       
       designate the private data member that is the wrapped pointer-like object.
      
       
        1)
       
       Constructs a
       
      
        propagate_const
       
       , default-initializing
       
        
         this
         
          -
         
         
          >
         
         t_
        
       
       .
      
       
        2)
       
       Explicitly defaulted move constructor that move constructs
       
        
         this
         
          -
         
         
          >
         
         t_
        
       
       from
       
        
         p.
         
          t_
         
        
       
       .
      
      
       
        3)
       
       Initializes
       
        
         this
         
          -
         
         
          >
         
         t_
        
       
       as if by direct-non-list-initialization from the expression
       
        
         std
         
          ::
         
         
          move
         
         
          (
         
         pu.
         
          t_
         
         
          )
         
        
       
       .
       
This constructor does not participate in overload resolution unless std:: is_constructible < T, U > :: value is true , and is
      This constructor does not participate in overload resolution unless std:: is_constructible < T, U > :: value is true , and is
        explicit
       
       if and only if
       
        
         
          
           std::
           
            is_convertible
           
          
         
         
          <
         
         U, T
         
          >
         
         
          ::
         
         
          value
         
        
       
       is
       
        
         
          false
         
        
       
       .
      
       
        4)
       
       Initializes
       
        
         this
         
          -
         
         
          >
         
         t_
        
       
       as if by direct-non-list-initialization with the expression
       
        
         
          
           std::
           
            forward
           
          
         
         
          <
         
         U
         
          >
         
         
          (
         
         u
         
          )
         
        
       
       .
       
This constructor does not participate in overload resolution unless std:: is_constructible < T, U > :: value is true and std:: decay_t < U > is not a specialization of
      This constructor does not participate in overload resolution unless std:: is_constructible < T, U > :: value is true and std:: decay_t < U > is not a specialization of
        propagate_const
       
       . This constructor is
       
        explicit
       
       if and only if
       
        
         
          
           std::
           
            is_convertible
           
          
         
         
          <
         
         U, T
         
          >
         
         
          ::
         
         
          value
         
        
       
       is
       
        
         
          false
         
        
       
       .
      
       
        5)
       
       Copy constructor is explicitly deleted.
       
      
        propagate_const
       
       is non-copyable.
      Parameters
| p | - | another 
          propagate_const
         object to move from | 
| pu | - | another 
          propagate_const
         object of a different specialization to move from | 
| u | - | another object to initialize the contained pointer with | 
Notes
       In Library Fundamental TS v2 (based on C++14),
       
        (4)
       
       and
       
        (5)
       
       are typically implemented in
       
        explicit
       
       /non-
       
        explicit
       
       overload pairs. Since Library Fundamental TS v3 (based on C++20), they can be implemented in conditional
       
        explicit
       
       specifiers.